Empty program: Difference between revisions

=={{header|360 Assembly}}==

Return to caller

=={{header|6502 Assembly}}==

===Commodore 64===

db $0E,$08,$0A,$00,$9E,$20,$28,$32,$30,$36,$34,$29,$00,$00,$00 ;required init code

 

===Nintendo Entertainment System===

Without an infinite loop the program counter will execute undefined behavior, depending on how "empty" bytes are padded. If we're generous and assume that empty bytes are padded with <code>NOP</code>, eventually the program counter will attempt to execute the interrupt vectors as executable code. If we assume that an "empty program" needs to not crash (even though you really can't tell the difference with nothing on screen), we need a way to "trap" the program counter.

 

RESET: ;execution starts here

JMP RESET

dw NMI ;FFFA-FFFB

dw RESET ;FFFC-FFFD ;this has to be defined or else the program counter will jump to an unknown location

 

=={{header|68000 Assembly}}==

After you get to the main program, you'll need to kick the watchdog every frame to prevent the BIOS from resetting the machine. This is done by writing any byte to memory address 0x00300001. Other than that, an endless loop will suffice (assuming you have a proper cartridge header and a vBlank routine that does nothing except check for bios vblank and return.)

 

MOVE.B D0,$300001

 

=={{header|8051 Assembly}}==

Continuously loops.

 

=={{header|8086 Assembly}}==

===Boot Sector Program===

start:

jmp start ;2 bytes

padding byte 508 dup (90h)

bootcode byte 55h,0AAh

 

If your assembler assembles the code above as an EXE file, you'll need to use a hex editor to strip the EXE header so that it fits exactly into 512 bytes.

 

===16-Bit x86 for EXE Files===

.stack 1024 ;this value doesn't matter, I chose this arbitrarily

.data

.code

mov ax,4C00h

 

===32-Bit x86===

 

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

 

global _start

 

xor edi, edi

syscall

 

=={{header|AArch64 Assembly}}==

Simulates system call exit(0). In AArch64, the system call number is passed via x8, and the syscall number for exit is 93.

.global _start

 

mov x0, #0

mov x8, #93

 

=={{header|ABAP}}==

Note that the statement "start-of-selection." is implicitly added. This event block needs to be present in executable programs, it's comparable to the main function in other programming languages.

 

report z_empty_program.

 

=={{header|Action!}}==

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Empty_program.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

{{works with|GCC|4.1.2}}

begin

null;

 

=={{header|Agena}}==

Actually nothing is valid code, too.

 

=={{header|Aime}}==

The nil input is a valid program.

 

=={{header|ALGOL 60}}==

 

=={{header|ALGOL 68}}==

=== Brief form ===

=== BOLD form ===

 

=={{header|ALGOL W}}==

In Algol W, a blank statement is a valid statement and a program is a statement followed by a dot. Hence "." is the smallest valid program.

 

=={{header|AmigaE}}==

 

=={{header|AppleScript}}==

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

 

=={{header|Argile}}==

The empty string or file are valid and do nothing.

 

=={{header|ARM Assembly}}==

===GNU/Linux RaspberryPi===

.global _start

_start:

mov r0, #0

mov r7, #1

 

===Game Boy Advance===

The first four bytes of the cartridge header are an unconditional branch instruction to the program's start. Simply duplicate this instruction at that address and voila:

 

 

Hardware interrupts will not occur if you never enable them, so there is no need to store the interrupt service procedure's address in address $03FFFFFC to prevent a crash. The Game Boy Advance has no "exit" <code>SWI</code> call (the closest is the undocumented hard reset) so this is as close as you can get.

 

=={{header|ArnoldC}}==

 

=={{header|Arturo}}==

A completely empty script is a valid Arturo program.

 

 

=={{header|Asymptote}}==

 

=={{header|AutoHotkey}}==

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

 

=={{header|AutoIt}}==

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

 

=={{header|Avail}}==

Avail files require a header block (that is generally omitted from the examples here). The shortest valid header would only include the module name, which can be reduced to 1 character, assuming the filename is set to match. For "a.avail", this gives the empty program:

This can be further shortened by removing unambiguous whitespace to:

For all practical purposes, this header is useless in any other program. It does not import the standard library "Avail" (or any alternatives), so it has access to no methods, types, or values. Here's a short program capable of output:

Or with more traditional spacing:

Uses "Avail"

Body

Note however that this output is only available as a ''compile-time'' side effect. A program defining a run-time entry point would include an <code>Entries</code> header section, or export its content for an entry point in another module to run.

 

 

The program

is the simplest useful program, equivalent to

I.e. match every input-line, and print it. <br>

Like the UNIX command 'cat', it prints every line of the files given as arguments,

=={{header|Axe}}==

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

 

=={{header|BASIC}}==

{{works with|uBasic/4tH}}

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:

0 OK, 0:1

 

==={{header|Applesoft BASIC}}===

 

=={{header|Batch File}}==

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 <code>: @ %</code>

 

=={{header|BaCon}}==

In BaCon an empty program is a valid program.

 

=={{header|BASIC256}}==

 

=={{header|BBC BASIC}}==

In BBC BASIC an empty program is syntactically correct.

 

=={{header|bc}}==

An empty file is a valid program.

 

=={{header|Beeswax}}==

 

(create 6 bees moving in all 6 cardinal directions)

or

(create 2 bees moving in “northwest” and “southeast” directions)

or

(create 2 bees moving left and right)

or

(create 2 bees moving in “northeast” and “southwest” directions)

 

 

=={{header|bootBASIC}}==

 

=={{header|BQN}}==

Any valid literal works to make a program run. The shortest way is to use a single digit, or a predefined constant, like <code>π</code> or <code>∞</code>.

 

[https://mlochbaum.github.io/BQN/try.html#code=4oie Try It!]

=={{header|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

 

In DOS, you can do

 

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

(Linux)

or

(Windows)

 

=={{header|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:

 

=={{header|C}}==

{{works with|C89}}

{

return 0;

 

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

{{works with|C99}}

 

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

{{works with|C on 8086 compatible processors}}

 

=={{header|C sharp|C#}}==

=={{header|C++}}==

{{works with|g++|4.8.1}}

 

=={{header|Clean}}==

 

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

 

=={{header|Clojure}}==

This is the shortest program that actually produces a working executable (that does nothing).

 

 

[[Portable CLU]] will compile the empty file without complaint, but not produce an

=={{header|COBOL}}==

{{works with|OpenCOBOL|2.0}}

 

=={{header|CoffeeScript}}==

 

=={{header|Common Lisp}}==

 

 

 

=={{header|Component Pascal}}==

BlackBox Component Builder;

MODULE Main;

END Main.

 

=={{header|Computer/zero Assembly}}==

The smallest legal program is a single Stop instruction.

 

=={{header|Crystal}}==

 

=={{header|D}}==

 

=={{header|Dart}}==

 

=={{header|dc}}==

Dyalect is not very happy with a completely empty source code file, however a pair of curly brackets would do:

 

 

This program would evaluate and return "nil".

 

=={{header|Déjà Vu}}==

Shortest module that works with <code>!import</code>:

 

=={{header|E}}==

<pre></pre>

This is equivalent to:

 

=={{header|eC}}==

<pre></pre>

or

{

void Main()

 

}

 

=={{header|EchoLisp}}==

 

=={{header|EDSAC order code}}==

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

GK [ set base address ]

ZF [ stop ]

 

=={{header|Egel}}==

The smallest program contains nothing.

 

=={{header|EGL}}==

General program

package programs;

 

end

end

Rich UI handler (but also without 'initialUI = [ ui ], onConstructionFunction = start' it would have been valid.)

<pre>

=={{header|Eiffel}}==

A file called root.e:

ROOT

 

end

 

=={{header|Elena}}==

ELENA 4.x

{

 

=={{header|Elixir}}==

 

=={{header|Elm}}==

--Language prints the text in " "

import Html

main =

Html.text"empty"

 

=={{header|Erlang}}==

An empty module:

An empty Erlang script file (escript):

 

=={{header|ERRE}}==

PROGRAM EMPTY

BEGIN

END PROGRAM

 

=={{header|eSQL}}==

CREATE FUNCTION Main() RETURNS BOOLEAN

BEGIN

RETURN TRUE;

END;

 

=={{header|Euphoria}}==

 

=={{header|F_Sharp|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.

An empty compiled program is:

 

=={{header|Factor}}==

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

: main ( -- ) ;

 

=={{header|Falcon}}==

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

{

public static Void main () {}

 

=={{header|FBSL}}==

 

=={{header|Fermat}}==

 

=={{header|Fish}}==

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.<br/>

The shortest program that will actually finish is a <tt>;</tt>, which will end the program immediately:

 

=={{header|Forth}}==

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.

 

=={{header|Fortran}}==

 

=={{header|FreeBASIC}}==

A completely empty program compiles and runs fine:

 

=={{header|friendly interactive shell}}==

Empty programs are valid, but are useless.

 

=={{header|Frink}}==

Empty programs are valid.

 

=={{header|FunL}}==

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

 

=={{header|Futhark}}==

Any Futhark program must have a <code>main</code> function. Alternatively, a Futhark library can be an empty file.

 

let main = 0

 

=={{header|FutureBasic}}==

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Gambas}}==

Public Sub Main()

End

 

=={{header|Gecho}}==

Empty programs are valid.

 

=={{header|Gema}}==

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

 

=={{header|Genyris}}==

=={{header|Global Script}}==

This program is intended for use with the [[HS Global Script]] and uses its syntax for imperative programs.

 

=={{header|Go}}==

 

=={{header|Groovy}}==

 

=={{header|Haskell}}==

 

The simplest possible program is a single module using the implicit module header "<tt>module Main(main) where</tt>", and defining the action <tt>main</tt> to do nothing:

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

 

=={{header|Haxe}}==

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.

 

=={{header|HicEst}}==

 

=={{header|HolyC}}==

=={{header|HTML}}==

HTML 5, [http://www.whatwg.org/specs/web-apps/current-work/multipage/syntax.html#optional-tags 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 [http://www.whatwg.org/specs/web-apps/current-work/multipage/semantics.html#the-head-element section 4.2.1 The head element]. There seems no rule against an empty title. Therefore, the shortest correct HTML document is:

 

The shortest correct XHTML document is:

 

=={{header|Huginn}}==

 

=={{header|i}}==

 

=={{header|Icon}} and {{header|Unicon}}==

 

=={{header|IDL}}==

 

=={{header|Inform 7}}==

Inform 7 is a language built for making interactive fiction, so a room needs to be defined for the player to start in.

 

=={{header|Intercal}}==

 

=={{header|Io}}==

 

=={{header|J}}==

It returns itself:

 

=={{header|Java}}==

{{works with|Java|1.5+}}

@Override public void init() {

}

 

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:

 

 

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

 

{{works with|Java|1.0+}}

public static void main(String[] args) {

}

 

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.

 

=={{header|Joy}}==

 

=={{header|Jq}}==

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

 

 

=={{header|Julia}}==

Julia accepts an empty file as a program.

 

{{out}}

 

=={{header|K}}==

 

=={{header|KonsolScript}}==

 

=={{header|Kotlin}}==

 

=={{header|Lambdatalk}}==

An empty string is a valid program.

 

=={{header|Lang5}}==

 

=={{header|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.

 

=={{header|LaTeX}}==

\begin{document}

 

=={{header|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).

 

=={{header|Liberty BASIC}}==

 

=={{header|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.

 

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

 

 

\header {

}

}

 

=={{header|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:

 

=={{header|Lisp}}==

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

 

=={{header|Little Man Computer}}==

 

'''Assembly'''

 

'''Machine code'''

 

=={{header|Logo}}==

or end a standalone script with "bye"

 

 

=={{header|LSE}}==

 

=={{header|LSE64}}==

 

=={{header|Lua}}==

 

=={{header|M2000 Interpreter}}==

 

File saved as:

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.

 

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

 

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

 

=={{header|M4}}==

 

=={{header|Maple}}==

 

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

 

=={{header|MATLAB}}==

 

=={{header|Maxima}}==

 

 

=={{header|MAXScript}}==

 

=={{header|MelonBasic}}==

 

=={{header|Metafont}}==

 

=={{header|Microsoft Small Basic}}==

{{out}}<pre></pre>

 

=={{header|min}}==

{{works with|min|0.19.3}}

 

=={{header|MiniScript}}==

 

=={{header|MIPS Assembly}}==

===Linux===

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

.text

main: li $v0, 10

syscall

===Nintendo 64===

In addition to a proper cartridge header, [[wp:Cyclic_redundancy_check|CRCs]], and footer, you'll need to write a value of <tt>8</tt> to address <tt>0xBFC007FC</tt> so that the cartridge can boot correctly. (Nintendo 64 is big-endian, so the 8 is actually stored at <tt>0xBFC007FF</tt>, but every example I've seen stores the value as a <code>uint32</code> so that's what I'm going with.)

After that, just enter an infinite loop and you're done.

 

li $t1,8

sw $t1,0($t0)

nop ;not actually needed by real hardware, but Project 64 doesn't like infinite loops.

b halt

 

=={{header|МК-61/52}}==

 

=={{header|ML/I}}==

 

=={{header|MMIX}}==

 

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

 

BEGIN

 

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

 

BEGIN

 

=={{header|MUMPS}}==

The empty file is a valid program.

<pre></pre>

 

=={{header|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}}

 

=={{header|Nanoquery}}==

Empty files are valid Nanoquery programs that do nothing.

 

=={{header|Nemerle}}==

Compiles with warnings:

Compiles without warnings (so, more correct):

{

Main() : void

{

}

 

=={{header|NetRexx}}==

 

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

 

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

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

 

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

 

=={{header|Objeck}}==

class Empty {

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

}

 

=={{header|Objective-C}}==

{{works with|gcc|4.0.1}}

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

}

return 0;

 

=={{header|OCaml}}==

{{works with|Ocaml|3.09}}

 

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

=={{header|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.

 

=={{header|Oforth}}==

An empty file is a valid oforth file

 

 

Without file, interpreter can just evaluate bye :

 

=={{header|Ol}}==

A file with any one-digit number ("0", "1", .. "9") or one-character function like "+", "-", etc.) is smallest non empty runnable code.

 

 

=={{header|OOC}}==

The Compiler will accept an empty file:

 

=={{header|OpenLisp}}==

This is for the Linux version of OpenLisp.

 

#!/openlisp/uxlisp -shell

()

 

=={{header|Openscad}}==

 

=={{header|OxygenBasic}}==

The smallest possible program is a single space character:

 

=={{header|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.)

define

skip

 

=={{header|PARI/GP}}==

 

=={{header|Pascal}}==

 

begin

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

 

=={{header|PepsiScript}}==

For typing:

 

#author .

 

For importing:

 

 

•dl◘.◙

 

=={{header|Perl}}==

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

 

 

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:

 

 

The smallest possible Perl one-liner is <code>perl -e0</code>.

{{libheader|Phix/basics}}

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

 

=={{header|PHP}}==

=={{header|Picat}}==

By default, Picat calls the <code>main/0</code> predicate:

 

{{out}}

 

An shorter way is this program

but then an explicit goal at command line (<code>-g x</code>) must be given.

 

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

 

=={{header|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.

 

=={{header|Pixilang}}==

Any text longer than 0 characters is valid, otherwise resulting in a "The file is empty or does not exist" error. In this example, a space character is used.

 

=={{header|PL/I}}==

 

=={{header|PL/SQL}}==

NULL;

 

=={{header|Plain English}}==

 

=={{header|plainTeX}}==

 

=={{header|Pony}}==

 

=={{header|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.

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:

define entry_point();

enddefine;

 

#_TERMIN_IF DEF POPC_COMPILING

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.

 

 

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

 

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

% ...or...

%!PS-3.0

 

=={{header|PowerShell}}==

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

&{}

 

{{Out}}

=={{header|Processing}}==

An empty .pde sketch file.

When run this will produce a 200x200 inactive default gray canvas.

 

=={{header|ProDOS}}==

This is an acceptable program:

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

 

=={{header|Programming Language}}==

For typing:

For importing:

 

 

=={{header|PSQL}}==

AS

BEGIN

 

=={{header|PureBasic}}==

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

 

=={{header|Python}}==

 

=={{header|QUACKASM}}==

 

=={{header|Quackery}}==

An empty string or text file is a valid Quackery program that does nothing.

 

 

{{out}}

 

=={{header|Quite BASIC}}==

 

=={{header|R}}==

=={{header|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

 

=={{header|Raku}}==

 

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

 

or even:

 

=={{header|Raven}}==

=={{header|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:

 

=={{header|Retro}}==

An empty file is the smallest valid program.

 

 

=={{header|REXX}}==

===version 1===

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

 

===version 2===

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

 

=={{header|Rhope}}==

 

=={{header|Ring}}==

 

=={{header|Robotic}}==

 

=={{header|Ruby}}==

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

 

=={{header|Run BASIC}}==

 

=={{header|Rust}}==

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

 

=={{header|Scilab}}==

 

=={{header|ScratchScript}}==

An empty program is invalid because it gives an [Err: Undefined] error. This behaviour still applies when the program isn't running. Due to this error, a program containing only an empty comment is the smallest possible valid program.

 

=={{header|Seed7}}==

 

=={{header|Set lang}}==

 

=={{header|Sidef}}==

 

=={{header|SimpleCode}}==

 

=={{header|Simula}}==

{{works with|SIMULA-67}}

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

 

=={{header|SNOBOL4}}==

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

 

=={{header|SNUSP}}==

 

=={{header|Sparkling}}==

 

=={{header|SQL PL}}==

{{works with|Db2 LUW}}

With SQL only:

SELECT 1 FROM sysibm.sysdummy1;

Output:

<pre>

{{works with|Db2 LUW}}

With SQL PL:

--#SET TERMINATOR @

 

BEGIN

END @

Output:

<pre>

{{works with|Db2 LUW}} version 9.7 or higher.

With SQL PL:

BEGIN

END;

Output:

<pre>

=={{header|SSEM}}==

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:

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

<pre> goto 1;

 

The smallest program that will terminate is:

 

=={{header|Standard ML}}==

 

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

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.

 

version 15

 

It's also possible to define an empty function in Mata.

 

 

=={{header|Suneido}}==

 

=={{header|Swift}}==

 

=={{header|Symsyn}}==

 

=={{header|Tcl}}==

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

 

=={{header|TI-83 BASIC}}==

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

:

 

=={{header|TI-83 Hex Assembly}}==

 

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

=={{header|Tiny BASIC}}==

An empty program works just fine.

 

=={{header|Toka}}==

 

=={{header|Trith}}==

 

=={{header|True BASIC}}==

 

=={{header|TUSCRIPT}}==

 

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}}

{{works with|Bourne Again SHell}}

{{works with|Korn SHell}}

 

=={{header|Unlambda}}==

=={{header|Ursa}}==

The Cygnus/X Ursa interpreter has no problems with empty files, so the shortest program is an empty file.

 

=={{header|Vala}}==

 

=={{header|VAX Assembly}}==

04 0002 2 ret ;return from main procedure

 

=={{header|VBA}}==

Same as Visual Basic, VB6, etc.

 

=={{header|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 <code>option explicit</code>.)

 

=={{header|Verbexx}}==

An empty file is the smallest valid script, but running it does nothing.

 

=={{header|Verilog}}==

 

=={{header|VHDL}}==

Compiled and simulated by Modelsim:

end;

 

architecture empty of dummy is

begin

 

=={{header|Vim Script}}==

=={{header|Visual Basic}}==

'''Works with:''' VB6

 

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|2005}}

Sub Main()

End Sub

 

<pre></pre>

{{out}}

 

A more reasonable example, that someone might guess was a V program, and not just an emptiness:

 

For an even better chance at guessing that the file is meant as V source code:

 

 

=={{header|Wart}}==

 

{{libheader|WASI}}

;;The entry point for WASI is called _start

(func $main (export "_start")

)

)

 

=={{header|Wee Basic}}==

 

=={{header|Wren}}==

 

=={{header|X86 Assembly}}==

{{works with|NASM|Linux}}

global _start

mov eax, 1

int 0x80

{{works with|MASM}}

.model flat, stdcall

option casemap:none

start:

ret

 

=={{header|XPL0}}==

 

=={{header|XQuery}}==

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

 

=={{header|XSLT}}==

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

<!-- code goes here -->

 

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 <code>transform</code> is a synonym for <code>stylesheet</code>, the example above can be minified to:

 

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

<template match="/" />

 

=={{header|xTalk}}==

 

=={{header|XUL}}==

<?xml version="1.0"?>

 

=={{header|Yabasic}}==

 

=={{header|Yorick}}==

Most 8-bit computers work in a similar fashion: The BASIC interpreter acts as an operating system, and your entire program is essentially a subroutine that BASIC will <code>CALL</code>. If you "return" from your program the computer will go back to BASIC.

 

 

===Game Boy===

The beginning of the cartridge header is a jump to the program's start.

 

nop ;not sure if this is needed but Game Boy is somewhat buggy at times and the tutorials I used all did it

di ;disable interrupts

foo:

 

=={{header|Zig}}==

 

=={{header|zkl}}==

An empty file/string is valid.

<pre></pre>

 

=={{header|Zoea}}==

program: empty

 

=={{header|Zoea Visual}}==

=={{header|Zoomscript}}==

For typing:

For importing: