In this task, the goal is to create the simplest possible program that is still considered "correct."

Programming Languages

Agena

Actually nothing is valid code, too. <lang agena></lang>

Aime

The nil input is a valid program. <lang aime></lang>

ALGOL 68

Brief form

BOLD form

AppleScript

An empty .scpt file is considered the smallest runnable code, but the following would also be acceptable. <lang applescript>return</lang>

Argile

The empty string or file are valid and do nothing. <lang Argile></lang>

ARM Assembly

GNU/Linux RaspberryPi example. <lang ARM_Assembly>.text

   .global _start

_start:

   mov r0, #0
   mov r7, #1
   svc #0 </lang>

AutoHotkey

An empty script would be enough. Adding "#Persistent" makes it persistent. <lang AutoHotkey>#Persistent</lang>

AutoIt

An a single comment can be considered a valid program that does nothing. <lang AutoIt>;nothing</lang>

AWK

The empty string (or file) is recognised as valid program that does nothing.

The program <lang awk> 1</lang> is the simplest useful program: like the UNIX command 'cat', it prints every line of the files given as arguments, or (if no arguments are given) the standard input.

BASIC

Works with: QBasic

Works with: ZX Spectrum Basic

On the ZX Spectrum, we can have a completely empty program with no lines. Here we attempt to run the empty program: <lang basic>RUN</lang>

0 OK, 0:1

Batch File

An empty batch file is syntactically correct and does nothing. <lang dos></lang> But on windows 7 an empty .bat file is not recognized and thus a character must exist in it: <lang dos>REM</lang>

BBC BASIC

In BBC BASIC an empty program is syntactically correct. <lang bbcbasic></lang>

Befunge

The halt command @ is required because code wraps around. An empty file would be an infinite loop.

Bracmat

An empty file is a valid program. However you need to load it, which requires a statement. In a Linux terminal, you could do <lang bracmat>touch empty bracmat 'get$empty'</lang>

In DOS, you can do <lang dos>touch empty bracmat get$empty</lang>

If we drop the requirement that the shortest program is stored in a file, we can do <lang bash>bracmat </lang> (Linux) or <lang dos>bracmat ""</lang> (Windows)

If two quotes to demarcate an empty string are counted as bigger than a single undemarcated non-empty expression, we can do

 bracmat .

The dot is a binary operator. So the input consists of three nodes: the operator and its lhs and rhs, both empty strings in this case. If three nodes is too much, consider a slightly bigger glyph, such as the hyphen, which is a prefix, not a binary operator:

 bracmat -

You also can start Bracmat without arguments, in which case it will run in interactive mode. Now press the Enter key. You have just run the shortest valid Bracmat program.

Brainf***

Empty program

Note: this works as all non-instruction characters are considered comments. Alternatively, a zero-byte file also works.

Brlcad

Pressing enter from the mged prompt, just returns another prompt, so I suppose that is the smallest possible program. However, before we can draw anything we at least need to open a database: <lang mged>opendb empty.g y</lang>

C

You'll notice that each example has an int return type, and returns 0. The meaning of the return value is system-dependent.

argc contains the number of arguments. argv is an array containing those arguments as null-terminated strings. These memory for these strings are maintained by the runtime, and don't need to be manually freed. <lang c>int main(int argc, char* argv[]) {

 return 0;

}</lang> It's also possible to empty signature for main function.

Works with: gcc version 4.0.3

<lang c>int main () {

 return 0;

}</lang> In versions of C before C99, it was possible to skip return type of function if it was int. This isn't allowed anymore, but some compilers allow it in C89 compatibility modes. <lang c>main () {

 return 0;

}</lang>

C#

<lang csharp>class Program {

   static void Main()
   {
   }

}</lang>

C++

Works with: g++ version 4.8.1

Clean

<lang clean>module Empty

Start world = world</lang> Compile the project with No Console or No Return Type to suppress printing of the value of the world.

Clojure

An empty file is the simplest valid Clojure program.

COBOL

Works with: OpenCOBOL version 2.0

CoffeeScript

Component Pascal

BlackBox Component Builder; <lang oberon2> MODULE Main; END Main. </lang>

D

Déjà Vu

<lang dejavu></lang> Shortest module that works with !import: <lang dejavu>{}</lang>

Dart

Delphi

See Pascal

E

The shortest possible program:

This is equivalent to: <lang e>null</lang>

eC

or <lang ec>class EmptyApp : Application {

   void Main()
   {

}</lang>

Eiffel

A file called root.e: <lang eiffel>class

   ROOT

create

   make

feature

   make
       do
          
       end

end</lang>

Erlang

An empty module: <lang erlang>-module(empty).</lang> An empty Erlang script file (escript): <lang erlang>main(_) -> 1.</lang>

eSQL

<lang sql>CREATE COMPUTE MODULE ESQL_Compute

 CREATE FUNCTION Main() RETURNS BOOLEAN
 BEGIN
   RETURN TRUE;
 END;

END MODULE;</lang>

Euphoria

EGL

General program <lang EGL> package programs;

program Empty_program type BasicProgram {} function main() end end </lang> Rich UI handler (but also without 'initialUI = [ ui ], onConstructionFunction = start' it would have been valid.)

package ruihandlers;

import com.ibm.egl.rui.widgets.Div;

handler Empty_program type RUIhandler {initialUI = [ ui ], onConstructionFunction = start}
	ui Div{};
	
	function start()
	end	
end

F#

F# has an interactive mode and a compiled mode. The interactive interpreter will accept an empty file so the shortest valid program is an empty zero-length file with the .fsx extension. <lang fsharp></lang> An empty compiled program is: <lang fsharp>[<EntryPoint>] let main args = 0</lang>

Factor

<lang factor></lang> If you want to deploy a stand-alone application, that doesn't suffice though. Here's another version. <lang factor>IN: rosetta.empty

main ( -- ) ;

MAIN: main</lang>

FBSL

An empty string is a valid FBSL script in both uncompiled and compiled form. It won't however produce any visible output on the screen. The minimum implementations for the user to see the result are presented below:

Console mode:

#APPTYPE CONSOLE PAUSE

Output:

Press any key to continue...

Graphics mode:

SHOW(ME) ' all FBSL scripts are #APPTYPE GUI on default BEGIN EVENTS END EVENTS

Output: GUI Form

Minimum empty Dynamic Assembler block:

DYNASM Foo() RET ; mandatory END DYNASM

Minimum empty Dynamic C block:

DYNC Foo() void main(void) { return; // optional } END DYNC

Falcon

Prints an empty line.

>>

Prints nothing.

FALSE

Fantom

<lang fantom>class Main {

 public static Void main () {}

}</lang>

Fish

Actually the shortest valid program is a space (not empty file!), which is an infinite loop, though. (It keeps looping around) <lang Fish> </lang> An empty program is invalid; the interpreter will give an error.
The shortest program that will actually finish is a ;, which will end the program immediately: <lang Fish>;</lang>

Forth

<lang forth></lang> For a Forth script to be used from a shell, you usually want the last command to be BYE in order to exit the interpreter when finished. <lang forth>bye</lang>

Fortran

friendly interactive shell

Empty programs are valid, but are useless. <lang fishshell></lang>

Frink

Empty programs are valid. <lang frink></lang>

Gecho

Empty programs are valid. <lang gecho></lang>

Gema

An empty program will copy input stream to output stream unchanged. <lang gema></lang>

Genyris

Go

<lang go>package main func main() { }</lang>

Groovy

Haskell

Standard: Haskell 98

The simplest possible program is a single module using the implicit module header "module Main(main) where", and defining the action main to do nothing: <lang haskell>main = return ()</lang> The simplest possible module other than Main is one which contains no definitions: <lang haskell>module X where {}</lang>

Haxe

<lang haxe>class Program {

   static function main() {
   }

}</lang> Unlike most languages Haxe doesn't have arguments in the main function because it targets different platforms (some which don't support program arguments, eg: Flash or Javascript). You need to use the specific libraries of the platform you are targeting to get those.

HicEst

<lang hicest>END ! looks better, but is not really needed</lang>

HQ9+

An empty file is a valid HQ9+ program that does nothing.

Icon and Unicon

<lang Icon>procedure main() # a null file will compile but generate a run-time error for missing main end</lang>

IDL

Intercal

<lang intercal>PLEASE GIVE UP</lang>

Io

J

<lang j></lang> It returns itself: <lang j> -: ". 1</lang>

Java

Works with: Java version 1.5+

<lang java>public class EmptyApplet extends java.applet.Applet {

   @Override public void init() {
   }

}</lang>

<lang java>public class EmptyMainClass {

   public static void main(String... args) {
   }

}</lang>

The "..." basically means "as many of these as the programmer wants." Java will put multiple arguments into an array with the given name. This will work for any method where an array is an argument, but with a twist. A call can be made like this:

<lang java>method(arg0, arg1, arg2, arg3)</lang>

All of the args will be put into an array in the order they were in the call.

Works with: Java version 1.0+

<lang java>public class EmptyMainClass {

   public static void main(String[] args) {
   }

}</lang>

<lang java>public class EmptyApplet extends java.applet.Applet {

   public void init() {
   }

}</lang>

@Override - Indicates that a method declaration is intended to override a method declaration in a superclass. If a method is annotated with this annotation type but does not override a superclass method, compilers are required to generate an error message. It's present from JDK 5.0 (1.5.0) and up.

Actually this is not strictly correct. The smallest possible correct program in Java is an empty source file.

JavaScript

The empty file is a valid program.

Joy

K

KonsolScript

<lang KonsolScript>function main() {

}</lang>

Lang5

Lasso

Lasso will parse any file thrown at it. It will ignore everything except what's inside specific Lasso delimiters. Thus a valid program that did nothing, could be an empty file. Perhaps more correct would be a file that had the specific delimiters and then nothing inside them. <lang Lasso>[]</lang> <lang Lasso><?lasso ?></lang> <lang Lasso><?= ?></lang>

Liberty BASIC

Lilypond

According to the manual, all lilypond programs should contain a version statement expressing the minimum version number. If this is missing then a warning will be emitted. <lang lilypond>\version "2.6.12"</lang>

An input file should really have a basic structure as follows. The compiler automatically adds some of the structure components if they are not present in the source code. However, explicit definition should be used to prevent the compiler from creating unwanted contexts (which can cause side effects):

<lang lilypond>\version "2.16.2"

\header {

}

\book {

 \score {
   \new Staff {
     \new Voice {

     }
   }
   \layout {

   }
 }

}</lang>

Lisp

Most Lisp dialects, including Common Lisp, will accept no text (no forms) as a valid program. <lang lisp></lang>

Logo

<lang logo></lang> or end a standalone script with "bye" <lang logo>#! /usr/local/bin/logo

bye</lang>

LSE64

As with Forth, an empty file is the shortest program. To exit the interpreter at the end of a loaded file:

bye

Lua

M4

Maple

Mathematica

MATLAB

<lang Matlab> function [varargout] = emptyprogram(varargin) </lang>

Maxima

<lang maxima>block()$</lang>

MAXScript

An empty MAXScript file returns "OK" on execution

Metafont

МК-61/52

ML/I

MMIX

Modula-2

<lang modula2>MODULE Main;

BEGIN END Main.</lang>

Modula-3

<lang modula3>MODULE Main;

BEGIN END Main.</lang>

MUMPS

The empty file is a valid program.

Nemerle

Compiles with warnings: <lang Nemerle>null</lang> Compiles without warnings (so, more correct): <lang Nemerle>module Program {

   Main() : void
   {
   }

}</lang>

NetRexx

The following two samples both generate valid programs.

This minimal example requires that the file be named to match the class: <lang NetRexx>class empty</lang>

This example will generate it's class based on the file name: <lang NetRexx>method main(args = String[]) static</lang>

NewLISP

Nimrod

Objeck

<lang objeck>bundle Default {

 class Empty {
   function : Main(args : String[]) ~ Nil {
   }

}</lang>

Objective-C

Works with: gcc version 4.0.1

<lang objc>int main(int argc, const char **argv) {

   return 0;

}</lang>

The minimal empty Cocoa/OpenStep application, useful as life-support for many examples given at RosettaCode, is <lang objc>#import <Cocoa/Cocoa.h>

int main( int argc, const char *argv[] ) {

 NSAutoreleasePool *pool;
 
 pool = [[NSAutoreleasePool alloc] init];
 NSApp = [NSApplication sharedApplication];
   
 [pool release];
 return 0;

}</lang>

OCaml

Works with: Ocaml version 3.09

Actually, the smallest possible correct program in OCaml is an empty source file.

Octave

An empty text file can be a valid empty program, but since Octave has the concept of "function file" (a file containing a single function; the file is automatically loaded when a function with the same name of the file, save for the extension, is called, and the first function present in the file is used), the name of the empty file matters. E.g. calling an empty file as isempty.m makes unusable the builtin isempty function.

OxygenBasic

The smallest possible program is a single space character: <lang oxygenbasic>

</lang>

Oz

REPL

This example is incorrect. It does not accomplish the given task. Please fix the code and remove this message.

The simplest program that can be evaluated in the REPL (Emacs mode) is the empty program. <lang oz></lang>

Accepted by compiler

The simplest 'program' that can be compiled is a file which contains a single expression. <lang oz>unit</lang> Such a 'program' cannot be executed, though.

Standalone

The simplest standalone program is a root functor that does not define anything. ("Functors" are first-class modules.) <lang oz>functor define

  skip

end</lang>

PARI/GP

Pascal

<lang pascal>program ProgramName;

begin end.</lang> The first line is not necessary in modern Pascal dialects. With today's most compilers, the empty program is just: <lang pascal>begin end.</lang>

Perl

Works with: Perl version 5.8.8

<lang perl>#!/usr/bin/perl 1;</lang> <lang perl>#!/usr/bin/perl exit;</lang> <lang perl>#!/usr/bin/perl

A program without a body will work too</lang>

<lang perl>#!/usr/bin/perl</lang> The smallest possible program is an empty file (zero length). This requires you to specify the interpreter instead of relying on the shell's shebang magic, thus: perl empty.pl.

The smallest possible Perl one-liner is perl -e0.

Perl 6

The empty program is valid and does nothing but return a successful exit code.

It is also possible to just specify that the program is written in Perl6: <lang>use v6;</lang> or, for relax mode (not yet implemented in rakudo, though): <lang>v6;</lang> or even: <lang>6;</lang>

PHP

An empty text file is a correct PHP program that does nothing.

PicoLisp

PIR

The :main pragma indicates that a subroutine is the program's entry point. However, if a subroutine is the first (or only, which would also have the effect of making it the first) routine in the program, Parrot will use that. So we may comfortably omit it in this case. <lang pir>.sub empty_program .end</lang>

Pike

PL/I

<lang PL/I>s: proc options (main); end;</lang>

PL/SQL

<lang sql>BEGIN

   NULL;

END;</lang>

Pop11

Pop11 has two compilers, incremental and batch compiler. For the incremental compiler one can use just empty program text (empty file), or a file containing nothing but a comment, e.g. <lang pop11>;;; This is a valid Pop11 program that does absolutely nothing.</lang> The batch compiler generates an executable which starts at a given entry point, so one should provide an empty function. If one wants program that works the same both with incremental compiler and batch compiler the following may be useful: <lang pop11>compile_mode :pop11 +strict; define entry_point(); enddefine;

_TERMIN_IF DEF POPC_COMPILING

entry_point();</lang> Here the batch compiler will stop reading source before call to entry_point while incremental compiler will execute the call, ensuring that in both cases execution will start from the function entry_point.

PostScript

An empty file is a valid PostScript program that does nothing.

Following good programming practice, however, and to ensure that a PostScript printer will interpret a file correctly, one should make the first 4 characters of the file be <lang postscript>%!PS</lang>

If a particular version of the PS interpreter is needed, this would be included right there: <lang postscript>%!PS-2.0 % ...or... %!PS-3.0 % etc</lang>

PowerShell

An empty text file is a correct Powershell script that does nothing.

PSQL

<lang sql>EXECUTE BLOCK AS BEGIN END</lang>

ProDOS

This is an acceptable program: <lang ProDOS>IGNORELINE</lang> But also you could include a delimiter character recognized by the compiler/interpreter: <lang ProDOS>;</lang>

PureBasic

An empty file is a correct PureBasic program that does nothing. <lang PureBasic></lang>

Python

An empty text file is a correct Python program that does nothing.

R

An empty text file is a valid empty program

Racket

The following shows an empty program in Racket's default language. Other Racket languages may impose different conditions on the empty program. <lang racket>

lang racket

</lang>

Raven

An empty text file is an empty program.

REBOL

The header section is mandatory if you want it to be recognized as a REBOL program. It doesn't have to be filled in though: <lang REBOL>REBOL []</lang>

Retro

An empty file is the smallest valid program. <lang Retro></lang>

To save an application doing nothing, you need to do a bit more work though: <lang Retro>&bye is boot</lang>

REXX

version 1

An empty (or blank) file is a valid REXX program.
However, for some REXX implementations the first line has to begin with a REXX comment (that is, /* --- namely a slash followed by an asterisk) in order to recognize that the file is a REXX script/EXEC/program: <lang rexx>/*comment*/</lang> Some environments (TSO under "MVS", certain IBM SAA environments, and possibly others) require that the first line begin with a (REXX) comment, and the (four) letters REXX be somewhere on the first line (within the comment).
The REXX character string may be in any case (lower/upper/mixed) and cannot contain imbedded whitespace.

SAA: (IBM's) Systems Application Architecture

version 2

version 3

REXX on MVS/TSO requires REXX to be in within a REXX comment that begins on the first line: <lang rexx>/*REXX*/</lang> <lang rexx>/*this REXX program calculates if a date is a workday for the XYZ Company.*/</lang>

Rhope

Works with: Rhope version alpha 1

Main(0,0)
|: :|

Ruby

An empty file is a valid Ruby program. However, in order to make it runnable on *nix systems, a shebang line is necessary: <lang ruby>#!/usr/bin/env ruby</lang>

Scala

<lang scala>object emptyProgram extends App {}</lang>

Scheme

Seed7

<lang seed7>$ include "seed7_05.s7i";

const proc: main is noop;</lang>

Slate

Smalltalk

SNUSP

$#

$ sets the instruction pointer (going right), and # halts the program (empty stack).

SNOBOL4

A valid program requires an end label. The shortest (virtually empty) program is then: <lang snobol>end</lang>

Standard ML

Actually, the smallest possible correct program in Standard ML is an empty source file.

Suneido

<lang Suneido>function () { }</lang>

Tcl

Nothing is mandatory in Tcl, so an empty file named nothing.tcl would be a valid "empty program". <lang tcl></lang>

Toka

For interpreted code, nothing is required, although bye is necessary for an empty script to exit (rather than wait for the user to exit the listener). Hence:

bye

Or, for a directly runnable script:

#! /usr/bin/toka
bye

For compiled code, the simplest program is an empty quote:

[ ]

Again, to exit the listener, you will still need user input if this is not followed with bye.

TI-83 BASIC

TI-89 BASIC

Prgm
EndPrgm

Trith

TUSCRIPT

<lang tuscript>$$ MODE TUSCRIPT</lang>

UNIX Shell

Works with: Bourne Shell

Works with: Bourne Again SHell

Unlambda

(See how i plays so many roles in unlambda?)

VBScript

An empty .vbs file is considered the smallest runnable code, but the following (a single apostrophe as comment marker) would also be acceptable (along with other non-executing instructions like option explicit.) <lang vb>'</lang>

VHDL

Compiled and simulated by Modelsim: <lang VHDL>entity dummy is end;

architecture empty of dummy is begin end;</lang>

Visual Basic .NET

Works with: Visual Basic .NET version 2005

<lang vbnet>Module General

   Sub Main()
   End Sub

End Module</lang>

Wart

X86 Assembly

Works with: NASM version Linux

<lang asm>section .text global _start

_start: mov eax, 1 int 0x80 ret</lang>

Works with: MASM

<lang asm>.386 .model flat, stdcall option casemap:none

.code start: ret end start</lang>

XPL0

An empty file compiles and builds an EXE file with a single RET instruction, but of course does nothing when executed.

XQuery

<lang xquery>.</lang> The dot selects the current context node and returns it unchanged.

XSLT

Add other namespaces to the stylesheet attributes (like xmlns:fo="http://www.w3.org/1999/XSL/Format") if you use them.

Since XSLT is XML, and transform is a synonym for stylesheet, the example above can be minified to: <lang xslt><transform xmlns="http://www.w3.org/1999/XSL/Transform" version="1.0"/></lang>

This stylesheet echoes the text content of an XML file. The shortest stylesheet without any output would be <lang xslt><transform xmlns="http://www.w3.org/1999/XSL/Transform" version="1.0">

  <template match="/" />

</transform></lang>

xTalk

Works with: HyperCard

on startup
  
end startup

XUL

Yorick

An empty file is valid and does nothing.

Markup Languages

HTML

HTML 5, section 11.1.2.4 Optional tags, allows to omit html, head and body tags. The implicit body element can be empty, but the implicit head element must contain a title element, says section 4.2.1 The head element. There seems no rule against an empty title. Therefore, the shortest correct HTML document is: <lang html5><!DOCTYPE html><title></title></lang>

The shortest correct XHTML document is: <lang html5><html xmlns="http://www.w3.org/1999/xhtml"><head><title /></head><body /></html></lang>

Plain $T e X$

$L a T e X$

<lang latex>\documentclass{article} \begin{document} \end{document}</lang>