Empty program

From Rosetta Code
Task
Empty program
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Create the simplest possible program that is still considered "correct."

Contents

Programming Languages[edit]

360 Assembly[edit]

Return to caller

         BR    14           
END

8051 Assembly[edit]

Continuously loops.

ORG RESET 
jmp $

8086 Assembly[edit]

end

However, if the program needs to exit with an exit code of zero:

    segment .text
global _start
 
_start:
mov eax, 60
xor edi, edi
syscall
end

Ada[edit]

Works with: GCC version 4.1.2
procedure Empty is 
begin
null;
end;

Agena[edit]

Actually nothing is valid code, too.

 

Aime[edit]

The nil input is a valid program.

 

ALGOL 60[edit]

'BEGIN' 'END'

ALGOL 68[edit]

Brief form[edit]

~

BOLD form[edit]

SKIP

ALGOL W[edit]

begin end.

AmigaE[edit]

PROC main()
ENDPROC

AppleScript[edit]

An empty .scpt file is considered the smallest runnable code, but the following would also be acceptable.

return

Argile[edit]

The empty string or file are valid and do nothing.

 

ARM Assembly[edit]

GNU/Linux RaspberryPi example.

.text
.global _start
_start:
mov r0, #0
mov r7, #1
svc #0

AutoHotkey[edit]

An empty script would be enough. Adding "#Persistent" makes it persistent.

#Persistent

AutoIt[edit]

A single comment can be considered a valid program that does nothing.

;nothing

AWK[edit]

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

The program

    1

is the simplest useful program, equivalent to

// {print}

I.e. match every input-line, and print it.
Like the UNIX command 'cat', it prints every line of the files given as arguments, or (if no arguments are given) the standard input.

Axe[edit]

Most Axe examples omit the executable name, but it is shown in this example for completeness.

:.PRGMNAME
:

BASIC[edit]

Works with: QBASIC
Works with: Quick BASIC
Works with: FreeBASIC

An empty file is a correct program. It won't be near empty as an executable file, though.

 
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:

RUN
0 OK, 0:1

Applesoft BASIC[edit]

 

Batch File[edit]

On Windows XP and older, an empty batch file is syntactically correct and does nothing.

 

But on Windows 7, an empty .bat file is not recognized and thus a character must exist in it. Some valid characters are : @ %

:

BBC BASIC[edit]

In BBC BASIC an empty program is syntactically correct.

 

bc[edit]

An empty file is a valid program.

Befunge[edit]

@

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

Bracmat[edit]

An empty file is a valid program. However you need to load it, which requires a statement. In a Linux terminal, you could do

touch empty
bracmat 'get$empty'

In DOS, you can do

touch empty
bracmat get$empty

If we drop the requirement that the shortest program is stored in a file, we can do

bracmat ''

(Linux) or

bracmat ""

(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***[edit]

Empty program

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

Brlcad[edit]

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:

opendb empty.g y

C[edit]

Works with: C89
main()
{
return 0;
}

As of C99 the return type is required, but the return statement is not.

Works with: C99
int main() { }

This is technically undefined behavior but on 8086 compatible processors 195 corresponds to the ret assembly instruction.

const main = 195;

C#[edit]

class Program
{
static void Main()
{
}
}

C++[edit]

Works with: g++ version 4.8.1
int main(){}

Clean[edit]

module Empty
 
Start world = world

Compile the project with No Console or No Return Type to suppress printing of the value of the world.

Clojure[edit]

An empty file is the simplest valid Clojure program.

COBOL[edit]

Works with: OpenCOBOL version 2.0
 

CoffeeScript[edit]

 

Common Lisp[edit]

()

Component Pascal[edit]

BlackBox Component Builder;

 
MODULE Main;
END Main.
 

D[edit]

void main() {}

Dart[edit]

main() {
}

dc[edit]

An empty file is a valid program.

DCL[edit]

An empty file is a valid program.

Déjà Vu[edit]

 

Shortest module that works with !import:

{}

Delphi[edit]

See Pascal

E[edit]

The shortest possible program:


This is equivalent to:

null

eC[edit]


or

class EmptyApp : Application
{
void Main()
{
 
}
}

EchoLisp[edit]

 
 

EDSAC order code[edit]

The smallest program that will load and run without error. Apart from ZF, the 'stop' order, it consists solely of directives to the loader.

T64K  [ set load point ]
GK [ set base address ]
ZF [ stop ]
EZPF [ begin at load point ]

EGL[edit]

General program

 
package programs;
 
program Empty_program type BasicProgram {}
function main()
end
end
 

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

Eiffel[edit]

A file called root.e:

class
ROOT
 
create
make
 
feature
make
do
 
end
end

Elixir[edit]

 

Erlang[edit]

An empty module:

-module(empty).

An empty Erlang script file (escript):

main(_) -> 1.

ERRE[edit]

 
PROGRAM EMPTY
BEGIN
END PROGRAM
 

eSQL[edit]

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

Elena[edit]

#symbol program =
[
].

Euphoria[edit]

 

F#[edit]

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.

 

An empty compiled program is:

[<EntryPoint>]
let main args = 0

Factor[edit]

 

If you want to deploy a stand-alone application, that doesn't suffice though. Here's another version.

IN: rosetta.empty
: main ( -- ) ;
MAIN: main

Falcon[edit]

>

Prints an empty line.

>>

Prints nothing.

FALSE[edit]

 

Fantom[edit]

class Main
{
public static Void main () {}
}

FBSL[edit]

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

Fish[edit]

Actually the shortest valid program is a space (not empty file!), which is an infinite loop, though. (It keeps looping around)

 

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:

;

Forth[edit]

 

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.

bye

Fortran[edit]

       end

friendly interactive shell[edit]

Empty programs are valid, but are useless.

 

Frink[edit]

Empty programs are valid.

 

FunL[edit]

An empty text file is a valid FunL program that does nothing.

 

Gecho[edit]

Empty programs are valid.

 

Gema[edit]

An empty program will copy input stream to output stream unchanged.

 

Genyris[edit]


Go[edit]

package main
func main() { }

Groovy[edit]

 

Haskell[edit]

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:

main = return ()

The simplest possible module other than Main is one which contains no definitions:

module X where {}

Haxe[edit]

class Program {
static function main() {
}
}

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[edit]

END ! looks better, but is not really needed

HQ9+[edit]

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

Icon and Unicon[edit]

procedure main()   # a null file will compile but generate a run-time error for missing main
end

IDL[edit]

end

Intercal[edit]

PLEASE GIVE UP

Io[edit]


J[edit]

 

It returns itself:

   '' -: ". ''
1

Java[edit]

Works with: Java version 1.5+
public class EmptyApplet extends java.applet.Applet {
@Override public void init() {
}
}
public class EmptyMainClass {
public static void main(String... args) {
}
}

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:

method(arg0, arg1, arg2, arg3)

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

Works with: Java version 1.0+
public class EmptyMainClass {
public static void main(String[] args) {
}
}
public class EmptyApplet extends java.applet.Applet {
public void init() {
}
}

@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[edit]

The empty file is a valid program.


Joy[edit]

 

Jq[edit]

The “empty” filter ignores its input and outputs nothing.

empty

Julia[edit]

Julia accepts an empty file as a program.

 
Output:
$ wc empty_program.jl
0 0 0 empty_program.jl
$ julia empty_program.jl
$

K[edit]

 

KonsolScript[edit]

function main() {
 
}

Kotlin[edit]

fun main(a: Array<String>) {}

Lang5[edit]

exit

Lasso[edit]

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.

[]
<?lasso  ?>
<?=  ?>

LC3 Assembly[edit]

The only thing you absolutely need is a directive telling the assembler to stop assembling code (which in this case it has not actually started doing).

        .END

Liberty BASIC[edit]

end

Lilypond[edit]

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.

\version "2.6.12"

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):

\version "2.16.2"
 
\header {
 
}
 
\book {
\score {
\new Staff {
\new Voice {
 
}
}
\layout {
 
}
}
}

Lisp[edit]

Most Lisp dialects, including Common Lisp, will accept no text (no forms) as a valid program.

 

[edit]

 

or end a standalone script with "bye"

#! /usr/local/bin/logo
 
bye

LSE64[edit]

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

bye

Lua[edit]

 

M4[edit]

 

Maple[edit]

 

Mathematica / Wolfram Language[edit]

 

MATLAB[edit]

 function [varargout] = emptyprogram(varargin) 

Maxima[edit]

block()$

MAXScript[edit]

An empty MAXScript file returns "OK" on execution

Metafont[edit]

end

МК-61/52[edit]

С/П

ML/I[edit]

 

MMIX[edit]

	LOC	#100
Main TRAP 0,Halt,0 // main (argc, argv) {}

Modula-2[edit]

MODULE Main;
 
BEGIN
END Main.

Modula-3[edit]

MODULE Main;
 
BEGIN
END Main.

MUMPS[edit]

The empty file is a valid program.


Nemerle[edit]

Compiles with warnings:

null

Compiles without warnings (so, more correct):

module Program
{
Main() : void
{
}
}

NetRexx[edit]

The following two samples both generate valid programs.

This minimal example requires that the file be named to match the class:

class empty

This example will generate its class based on the file name:

method main(args = String[]) static

NewLISP[edit]

; 

Nim[edit]


Nit[edit]

Although a Nit module (file) usually include a module declaration, an empty module is a valid Nit program.


Objeck[edit]

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

Objective-C[edit]

Works with: gcc version 4.0.1
int main(int argc, const char **argv) {
return 0;
}

The minimal empty Cocoa/OpenStep application, useful as life-support for many examples given at RosettaCode, is

#import <Cocoa/Cocoa.h>
 
int main( int argc, const char *argv[] )
{
@autoreleasepool {
[NSApplication sharedApplication];
}
return 0;
}

OCaml[edit]

Works with: Ocaml version 3.09
;;

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

Octave[edit]

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.

Oforth[edit]

An empty file is a valid oforth file

oforth empty.of

Without file, interpreter can just evaluate bye :

oforth --P"bye"

OOC[edit]

The Compiler will accept an empty file:

 

OpenLisp[edit]

We can run OpenLisp in shell mode with an empty program as follows. This is for the Linux version of OpenLisp.

 
#!/openlisp/uxlisp -shell
()
 

OxygenBasic[edit]

The smallest possible program is a single space character:

 
 
 

Oz[edit]

Accepted by compiler[edit]

The simplest 'program' that can be compiled is a file which contains a single expression.

unit

Such a 'program' cannot be executed, though.

Standalone[edit]

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

functor
define
skip
end

PARI/GP[edit]

 

Pascal[edit]

program ProgramName;
 
begin
end.

The first line is not necessary in modern Pascal dialects. With today's most compilers, the empty program is just:

begin end.

Perl[edit]

Works with: Perl version 5.8.8
#!/usr/bin/perl
1;
#!/usr/bin/perl
exit;
#!/usr/bin/perl
# A program without a body will work too
#!/usr/bin/perl

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[edit]

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:

use v6;

or, for relax mode (not yet implemented in rakudo, though):

v6;

or even:

6;

Phix[edit]

An empty file is a valid program. When compiled however, it is far from empty as it contains most of the VM and a full run-time diagnostics kit (together about 202K).

PHP[edit]

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

PicoLisp[edit]

(de foo ())

Pike[edit]

int main(){}

PIR[edit]

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.

.sub empty_program
.end

PL/I[edit]

s: proc options (main);
end;

PL/SQL[edit]

BEGIN
NULL;
END;

Pop11[edit]

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.

;;; This is a valid Pop11 program that does absolutely nothing.

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:

compile_mode :pop11 +strict;
define entry_point();
enddefine;
 
#_TERMIN_IF DEF POPC_COMPILING
entry_point();

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[edit]

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

%!PS

If a particular version of the PS interpreter is needed, this would be included right there:

%!PS-2.0
% ...or...
%!PS-3.0
% etc


PowerShell[edit]

An empty script block. A script block is a nameless (lamda) function.

 
&{}
 
Output:

ProDOS[edit]

This is an acceptable program:

IGNORELINE

But also you could include a delimiter character recognized by the compiler/interpreter:

;

PSQL[edit]

EXECUTE BLOCK
AS
BEGIN
END

PureBasic[edit]

An empty file is a correct PureBasic program that does nothing.

 

Python[edit]

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

QUACKASM[edit]

1
QUIT

R[edit]

An empty text file is a valid empty program

Racket[edit]

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

 
#lang racket
 

Raven[edit]

An empty text file is an empty program.

REBOL[edit]

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:

rebol []

Retro[edit]

An empty file is the smallest valid program.

 

To save an application doing nothing, you need to do a bit more work though:

&bye is boot

REXX[edit]

An empty (or blank) file is a valid REXX program.

Some REXX implementations require a special comment   [(1st word in the comment
must be   REXX   (in upper/lower/mixed) case]   to distinguish from other types of
scripting languages, but a null program (or a program with only blanks in it)   in those
other scripting languages are also considered an empty program.

version 1[edit]

This program can be empty (no characters),   or a program with (only) one or more blanks.

 

version 2[edit]

REXX on MVS/TSO requires REXX to be in within a REXX comment that begins on the first line:

/*REXX*/

Rhope[edit]

Works with: Rhope version alpha 1
Main(0,0)
|: :|

Ring[edit]

 

Ruby[edit]

An empty file is a valid Ruby program. However, in order to make it runnable on *nix systems, a shebang line is necessary:

#!/usr/bin/env ruby

Rust[edit]

fn main(){}

Scala[edit]

object emptyProgram extends App {}

Scheme[edit]

 

Scilab[edit]

 

Seed7[edit]

$ include "seed7_05.s7i";
 
const proc: main is noop;

Sidef[edit]

 

Simula[edit]

Works with: SIMULA-67
BEGIN
END

Slate[edit]

 

Smalltalk[edit]

[]

SNOBOL4[edit]

A valid program requires an end label. The shortest (virtually empty) program is then:

end

SNUSP[edit]

$#

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

Sparkling[edit]

 

SSEM[edit]

A completely empty program—all store bits clear, just power the machine up and hit Run—is meaningful in SSEM code and even does something, although not something desirable:

00000000000000000000000000000000   0. 0 to CI    jump to store(0) + 1
00000000000000000000000000000000 1. 0 to CI jump to store(0) + 1

Since the number in address 0 is 0, this is equivalent to

    goto 1;
1:  goto 1;

and has the effect of putting the machine into an infinite loop.

The smallest program that will terminate is:

00000000000001110000000000000000   0. Stop

Standard ML[edit]

;

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

Suneido[edit]

function () { }

Swift[edit]

 

Symsyn[edit]

 

Tcl[edit]

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

 

TI-83 BASIC[edit]

 

Displays "Done". If an empty program isn't valid, there are numerous other one-byte solutions:

:
Disp
Return
Stop

TI-89 BASIC[edit]

Prgm
EndPrgm

Toka[edit]

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.

Trith[edit]

 

TUSCRIPT[edit]

$$ MODE TUSCRIPT

UNIX Shell[edit]

Works with: Bourne Shell
#!/bin/sh
Works with: Bourne Again SHell
#!/bin/bash

Unlambda[edit]

i

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

VBScript[edit]

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.)

'

VHDL[edit]

Compiled and simulated by Modelsim:

entity dummy is
end;
 
architecture empty of dummy is
begin
end;

Vim Script[edit]

An empty file is a valid program.

Visual Basic[edit]

Works with: VB6

Sub Main()
End Sub

Visual Basic .NET[edit]

Works with: Visual Basic .NET version 2005
Module General
Sub Main()
End Sub
End Module

Wart[edit]


X86 Assembly[edit]

Works with: NASM version Linux
section .text
global _start
 
_start:
mov eax, 1
int 0x80
ret
Works with: MASM
.386
.model flat, stdcall
option casemap:none
 
.code
start:
ret
end start

XPL0[edit]

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


XQuery[edit]

.

The dot selects the current context node and returns it unchanged.

XSLT[edit]

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<!-- code goes here -->
</xsl:stylesheet>

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:

<transform xmlns="http://www.w3.org/1999/XSL/Transform" version="1.0"/>

This stylesheet echoes the text content of an XML file. The shortest stylesheet without any output would be

<transform xmlns="http://www.w3.org/1999/XSL/Transform" version="1.0">
<template match="/" />
</transform>

xTalk[edit]

Works with: HyperCard
on startup
  
end startup

XUL[edit]

 
<?xml version="1.0"?>
 

Yorick[edit]

An empty file is valid and does nothing.


Z80 Assembly[edit]

ret

zkl[edit]

An empty file/string is valid.


c:=Compiler.Compiler.compileText("");
c() //--> Class(RootClass#)

Markup Languages[edit]

HTML[edit]

HTML 5, section 12.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:

<!DOCTYPE html><title></title>

The shortest correct XHTML document is:

<html xmlns="http://www.w3.org/1999/xhtml"><head><title /></head><body /></html>

LaTeX[edit]

\documentclass{article}
\begin{document}
\end{document
}

plainTeX[edit]

\bye