KonsolScript

function main() {

}

Kotlin

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

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.

```Lasso
[]

```Lasso><?=  ?></lang



## LaTeX


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

LC3 Assembly

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

## Liberty BASIC


```lb>end</lang



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

```lilypond
\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 {

    }
  }
}

Lingo

"Program" doesn't really apply to Lingo. A Director projector (exe/app) doesn't have to contain any scripts/code. For scripts, the shortest possible code is:

## Lisp

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

```lisp></lang



## Logo


```logo></lang

or end a standalone script with "bye"

```logo
#! /usr/local/bin/logo

bye

LSE64

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

Lua

## M2000 Interpreter

Open M2000 Environment, type Edit A and place one space or insert a new line, then exit pressing Esc and write Save Empty (press enter). Now write New (press enter). Now write Load Empty (press enter) and execute it: write A (press enter). Now you can close environment: write End (press enter).

To open file Empty.gsb, as text file (without loading to list of modules) use Edit "Empty.Gsb". To open it in notepad, we can use this command from M2000 console: win "notepad", dir$+"empty.gsb"

We can open explorer for dir$ (the m2000 user directory) using Win Dir$  (we can use paths without quotes if no space includes, so win c:\ open explorer to c:)

File saved as:

```M2000 Interpreter

MODULE GLOBAL A {
}

Because we make it in "level 0" (from console) this is a global module. A global module which loaded from console, or was a module loaded from a file at command line, when opening the environment, erased with an End, or a New, or a Start statement (reset of environment by software), or a Break by keyboard (although a dialog ask for proceed the breaking, the reset of environment) , or in some situation by using End Process from Task Manager.

If we wish to run it from command line (by clicking the file in explorer, and let m2000.exe open gsb files), we have to consider the first that this file not contain an execute statement, and that if we didn't use an input statement/function which need console, then console stay hide. To be sure that console open we have to use Show statement. To run A we have to include A at the last line (or append a line and write A). So we write in first line Show (press Esc to return to prompt) and save the file as Save Empty, A so we get this:

MODULE GLOBAL A {Show
}
A

We can open it with Edit "empty.gsb" add some statements between A and block of module, to make some globals, say a DIM a(10) which stay there until the end of current interpreter run (interpreter may run multiple times simultaneously). All globals are globals for current interpreter only.

We can run empty.gsb now (supposed we save it as Save Empty, A), from explorer or using a command in M2000 console which opens another interpreter (and can feed it with some numbers or and strings, but this is another story):

Use empty

So now we see environment again, with open console and at prompt (execution done, and stay open because no End statement executed after the A, or inside module as Set End). Set used to send commands to prompt by code.

Finally this is the code in a file (say Empty.gsb) to open, display something, waiting for a key (now a Show automatic happen) and then finish. We have to write it, in M2000 editor, and save it using Save Empty, A or in any editor and save it as empty.gsb in your desired folder. sav

MODULE GLOBAL A {
Print "Hello World"
a$=Key$
Set End
}
A

We can save it scrabbled text using Save "empty" @, A (not readable, but environment can revert the process using a unique key)

(m2000 is open source so key is not a mystery, but you can make your own clone, and use own key)

M4

## Maple


```Maple></lang


=={{header|Mathematica}} / {{header|Wolfram Language}}==

```Mathematica></lang



## MATLAB


```Matlab
 function [varargout] = emptyprogram(varargin)

Maxima

block()$

MAXScript

An empty MAXScript file returns "OK" on execution

Metafont

## Microsoft Small Basic


```smallbasic></lang

{{out}}
```txt

min

{{works with|min|0.19.3}}

## MiniScript


```MiniScript></lang


=={{header|MK-61/52}}==
<lang>С/П

MIPS Assembly

This just exits the program with exit code 0 (exit_success)

	.text
main: 	li 	$v0, 10
	syscall

ML/I

## MMIX


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

=={{header|Modula-2}}==

MODULE Main;

BEGIN
END Main.

=={{header|Modula-3}}==

MODULE Main;

BEGIN
END Main.

MUMPS

The empty file is a valid program.

N/t/roff

{{works with|All implementations of TROFF}}

An empty input file is valid, but if the output is Postscript or PDF, most PDF viewers will suffer.  However, that's the PDF viewer's fault; the typesetter is still okay with an empty file.  If one wants grace for the PDF viewers, import a macro that, at the very least, defines some proper margins and pagination as in the following code:

{{works with|GNU TROFF|1.22.2}}

```N/t/roff>.mso me.tmac</lang



## Nemerle

Compiles with warnings:

```Nemerle>null</lang

Compiles without warnings (so, more correct):

```Nemerle
module Program
{
    Main() : void
    {
    }
}

NetRexx

The following two samples both generate valid programs.

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

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

```NetRexx
method main(args = String[]) static

NewLISP

## Nim


```txt

Nit

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

=={{header|NS-HUBASIC}}==

## Objeck


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

=={{header|Objective-C}}== {{works with|gcc|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

int main( int argc, const char *argv[] )
{
  @autoreleasepool {
    [NSApplication sharedApplication];
  }
  return 0;
}

OCaml

{{works with|Ocaml|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 <tt>isempty.m</tt> makes unusable the builtin <tt>isempty</tt> function.


## Oforth


An empty file is a valid oforth file


```Oforth>oforth empty.of</lang


Without file, interpreter can just evaluate bye :

```Oforth
oforth --P"bye"

OOC

The Compiler will accept an empty file:

## OpenLisp


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


```openlisp

#!/openlisp/uxlisp -shell
()

OxygenBasic

The smallest possible program is a single space character:

Oz

Accepted by compiler

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

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

```oz
functor
define
   skip
end

PARI/GP

## Pascal


```pascal
program ProgramName;

begin
end.

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

## Perl


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


```perl></lang


Of course, this then requires you to specify the interpreter on the command line (i.e. <code>perl empty.pl</code>). So slightly more correct as a stand-alone program, is:


```perl
#!/usr/bin/perl

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:

```perl6>use v6;</lang


or even:

```perl6>v6;</lang



## Phix

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

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


## PicoLisp


```PicoLisp
(de foo ())

Pike

int main(){}

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.

.sub empty_program
.end

PL/I

s: proc options (main);
end;

PL/SQL

BEGIN
    NULL;
END;

plainTeX

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

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

```pop11
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

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

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

&{}

{{Out}}

ProDOS

This is an acceptable program:

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

```ProDOS>;</lang



## PSQL


```sql
EXECUTE BLOCK
AS
BEGIN
END

PureBasic

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

## Python

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

An empty file named <code>__init__.py</code> even has a structural purpose in Python of declaring that a directory is a [https://docs.python.org/3/tutorial/modules.html#packages Package].


## QUACKASM


```quackasm
1
QUIT

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

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:

REBOL []

Retro

An empty file is the smallest valid program.

## REXX

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

Some REXX implementations require a special comment   [(1<sup>st</sup> 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

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

```rexx></lang



### version 2

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

```rexx
/*REXX*/

Rhope

{{works with|Rhope|alpha 1}} Main(0,0) |: :|

Ring

## Robotic


```robotic></lang



## Ruby

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

```ruby
#!/usr/bin/env ruby

Run BASIC

end  ' actually a blank is ok

Rust

fn main(){}

Scala

object emptyProgram extends App {}

Scheme

## Scilab


```scilab></lang



## Seed7


```seed7
$ include "seed7_05.s7i";

const proc: main is noop;

Set lang

## Simula

{{works with|SIMULA-67}}

```simula
BEGIN
END

## Smalltalk


```smalltalk
[]

## SNUSP

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


## Sparkling


```Sparkling></lang



## SQL PL

{{works with|Db2 LUW}}
With SQL only:

```sql pl

SELECT 1 FROM sysibm.sysdummy1;

db2 -t
db2 => SELECT 1 FROM sysibm.sysdummy1;

1
------------
           1

  1 record(s) selected.

--#SET TERMINATOR @

CREATE PROCEDURE myProc ()
 BEGIN
 END @

db2 -td@
db2 => CREATE PROCEDURE myProc ()
...
db2 (cont.) =>  END @
DB20000I  The SQL command completed successfully.

BEGIN
END;

db2 -t
db2 => BEGIN
db2 (cont.) => END;
DB20000I  The SQL command completed successfully.

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

    goto 1;
1:  goto 1;

## Standard ML


```sml>;</lang


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


## Stata

Stata does not accept an empty program, so we have to do something. Here we only declare the minimum [http://www.stata.com/help.cgi?version version] of the interpreter for the program.


```stata
program define nop
        version 15
end

function nop() {}

function () { }

## Symsyn


```Symsyn></lang



## Tcl

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

```tcl></lang


=={{header|TI-83 BASIC}}==
<lang TI-BASIC>

=={{header|TI-89 BASIC}}==
 Prgm
 EndPrgm


## 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'''.


## Trith


```trith></lang



## TUSCRIPT


```tuscript
$$ MODE TUSCRIPT

#!/bin/sh

#!/bin/bash

#!/bin/ksh

## VAX Assembly


```VAX Assembly
0000  0000     1 .entry	main,0	;register save mask
  04  0002     2 	ret	;return from main procedure
      0003     3 .end	main	;start address for linker

'

## VHDL

Compiled and simulated by Modelsim:

```VHDL
entity dummy is
end;

architecture empty of dummy is
begin
end;

Sub Demo()
End Sub

Sub Main()
End Sub

Module General
    Sub Main()
    End Sub
End Module

## X86 Assembly

{{works with|NASM|Linux}}

```asm
section .text
	global _start

	_start:
		mov eax, 1
		int 0x80
		ret

.386
.model flat, stdcall
option casemap:none

.code
start:
ret
end start

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


## XSLT


```xslt
<?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>

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

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

<?xml version="1.0"?>

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