List of Hello World Programs in 200 Programming Languages

by Scriptol.com

A complete collection of the smallest possible programs, in each existing programming language. This list is universal, comprised of programming languages and document formats.


A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

A

4GL

message "Hello, World!" with style = popup;

Abap

WRITE 'Hello, World!'.

Abc

WRITE "Hello, World!"

ActionScript

trace("Hello, World!");

Ada

with TEXT_IO;

procedure HELLO is
begin
TEXT_IO.PUT_LINE ("Hello, World!");
end HELLO;

ALGOL 60

'BEGIN'
'COMMENT' In Algol 60;
OUTPUT(4,'(''('Hello World!')',/')')
'END

ALGOL 68

BEGIN
  print(("Hello, World!", newline))
END

Using the short form of begin and end:

( print("Hello, World!") )

Alma-0

Hello, World!

AmigaE

PROC main()
WriteF('Hello, World!');
ENDPROC

Apl

'Hello, World!'

AppleScript

return "Hello, World!"
or:
-- "Hello World!"
Graphical:
display dialog "Hello World!" buttons {"OK"} default button 1

Ascii

In hexadecimal notation (0D = carriage return, 0A = newline):

48 65 6C 6C 6F 2C 20 77 6F 72 6C 64 21 0D 0A

Asp

<%
Response.Write("Hello, World!")
%>
or:
<%="Hello, World!" %>

Asp.Net

Response.Write("Hello, World!")

AspectJ

public aspect HelloWorld 
{
pointcut mainCall() : call(public static void *.main(String[] args));
before() : mainCall()
{
System.out.println( "Hello World!" );
}
}

Assembly language

6502 assembler

MSG: .ASCIIZ "Hello, World!"
START: LDX #0
LOOP: LDA MSG,X ; load character
JSR $FFD2 ; output to current output device
INX
BNE @LOOP
RTS

Intel x86, Dos, Tasm

MODEL SMALL
IDEAL
STACK 100H
DATASEG
MSG DB 'Hello, World!', 13, '$'
CODESEG
Start:
MOV AX, @data
MOV DS, AX
MOV DX, OFFSET MSG
MOV AH, 09H ; output ascii string
INT 21H
MOV AX, 4C00H
INT 21H
END Start

Intel x86, Linux

SECTION .data
msg:
db "Hello, World!\n"
len equ $ - msg
SECTION .text
global start
start:
mov edx,len
mov ecx,msg
mov ebx,1
mov eax,4
int 0x80
mov ebx,0
mov eax,1
int 0x80

Assembler 68000:

move.l #helloworld,-(A7)
move #9,-(A7)
trap #1
addq.l #6,A7
move #0,-(A7)
trap #1
helloworld:
dc.b "Hello World!",$0d,$0a,0

Arm, Risc OS:

.program 
ADR R0,message
SWI "OS_Write0"
SWI "OS_Exit"
.message
DCS "Hello, World!"
DCB 0
ALIGN

or the even smaller version (from qUE):

 SWI"OS_WriteS":EQUS"Hello, World!":EQUB0:ALIGN:MOVPC,R14

Risc processor and Mips architecture

 .data
msg: .asciiz "Hello, World!"
.align 2
.text
.globl main
main:
la $a0,msg
li $v0,4
syscall
jr $ra

AutoHotkey

MsgBox, "Hello, World!"

Autoit

MsgBox(1,'','Hello, World!')

Avenue - Scripting language for ArcView GIS

MsgBox("Hello, World!","aTitle")

Awk

# Hello
BEGIN { print "Hello, World!" }

B

B

/* Hello */

main()
{
extern a, b, c;
putchar (a); putchar (b); putchar (c); putchar ('!*n');
}

a 'hell' ;
b 'o, w' ;
c 'orld' ;

Bash

#!/bin/sh
echo "Hello, World!"

Basic

General

ANSI/ISO-compliant BASIC implementation. The "END" statement is optional in many implementations of BASIC.

10 PRINT "Hello, World!"
20 END

Immediate mode.

PRINT "Hello, World!"
? "Hello, World!"

Later implementations of BASIC. Again, the "END" statement is optional in many BASICs.

PRINT "Hello, World!"
END

DarkBasic

PRINT "HELLO WORLD"
TEXT 0,0,"Hello, World!"
WAIT KEY

PBasic

DEBUG "Hello, World!", CR

or, the typical microcontroller Hello World program equivalent with the only output device present being a light-emitting diode (LED) (in this case attached to the seventh output pin):

DO
HIGH 7 'Make the 7th pin go high (turn the LED on)
PAUSE 500 'Sleep for half a second
LOW 7 ' Make the 7th pin go low (turn the LED off)
PAUSE 500 'Sleep for half a second
LOOP
END

StarOffice/OpenOffice Basic

sub main
print "Hello, World!"
end sub

Visual Basic

Sub Main()
Print "Hello, World!"
End Sub

Visual Basic .Net

Module HelloWorldApp
Sub Main()
System.Console.WriteLine("Hello, World!")
End Sub
End Module

or:,

Class HelloWorldApp
Shared Sub Main()
System.Console.WriteLine("Hello, World!")
End Sub
End Class

Bcpl

// Hello

GET "LIBHDR"

LET START () BE
$(
WRITES ("Hello, World!*N")
$)

Beta

{ *** Hello ***}
(#
do
'Hello World!'->putLine
#)

Bliss

%TITLE 'HELLO_WORLD'
MODULE HELLO_WORLD (IDENT='V1.0', MAIN=HELLO_WORLD,
ADDRESSING_MODE (EXTERNAL=GENERAL)) =
BEGIN

LIBRARY 'SYS$LIBRARY:STARLET';

EXTERNAL ROUTINE
LIB$PUT_OUTPUT;

GLOBAL ROUTINE HELLO_WORLD =
BEGIN
LIB$PUT_OUTPUT(%ASCID %STRING('Hello, World!'))
END;

END
ELUDOM

Boo

print "Hello, World!"

C

C (ANSI)

#include <stdio.h>

/* Hello */
int main(void) {
printf("Hello, World!");
return 0;
}

C Windows

#include <windows.h>
int WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow )
{
MessageBox( NULL, "Hello World!\n", "", MB_OK );
return 0;
}
</windows.h>

C#

using System;
class HelloWorld
{
public static void Main()
{
System.Console.WriteLine("Hello, World!");
}
}

C++ (ISO)

#include <iostream>

int main()
{
std::cout << "Hello, World!\n";
}

C++ / Cli

int main()
{
System::Console::WriteLine("Hello, World!");
}

C++ Managed (.Net)

#using <mscorlib.dll>

using namespace System;

int wmain()
{
Console::WriteLine("Hello, World!");
}

Caml light

(* Hello World *)

let hello =
print_string "Hello World!";
;;

Cil

.method public static void Main() cil managed
{
.entrypoint
.maxstack 8
ldstr "Hello, World!"
call void [mscorlib]System.Console::WriteLine(string)
ret
}

Clean

module hello

Start = "Hello, World!"

Clist

PROC 0
WRITE Hello, World!

Clipper

? "Hello, World!"

Clu

start_up = proc ()
po: stream := stream$primary_output ()
stream$putl (po, "Hello, World!")
end start_up

Cobol

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.

ENVIRONMENT DIVISION.

DATA DIVISION.

PROCEDURE DIVISION.
DISPLAY "Hello, World!".
STOP RUN.

Cocoa or GnuStep (Objective C)

#import <Cocoa/Cocoa.h>
@interface hello : NSObject {
}
@end

@implementation hello

-(void)awakeFromNib
{
NSRunAlertPanel(@"Message from your Computer", @"Hello, World!", @"Hi!",
nil, nil);
}

@end

CoffeeScript

alert "Hello World!"

ColdFusion

<cfoutput>Hello, World!</cfoutput>

Comal

PRINT "Hello, World!"

Curl

{curl 3.0, 4.0 applet}
{curl-file-attributes character-encoding = "utf-8"}

Hello, World!

D

D

import std.stdio ;
void main () {
writef("Hello, World!");
}

Dart

main() 
{
print('Hello, World!');
}

Dataflex

/tela
Hello world
/*
clearscreen
page tela

dBase

* Hello World in dBase IV
? "Hello World!"

Dcl batch

$ write sys$output "Hello, World!"

Delphi, Kylix

program Hello_World;
uses
Windows;

begin
ShowMessage("Hello, World!");
end.

Doll

this::operator()
{
import system.cstdio;
puts("Hello, World!");
}

Dylan

module: hello

format-out("Hello, World!\n");

E

Ed and Ex (Ed extended)

a
hello World!
.
p

EGL

Program Hello
const MYVAR string = "Hello World!";
function main()
SysLib.writeStdOut(MYVAR);
end
end

Eiffel

class HELLO_WORLD

creation
make
feature
make is
local
io:BASIC_IO
do
!!io
io.put_string("%N Hello, World!")
end -- make
end -- class HELLO_WORLD

Elan

(* Elan *)
putline ("Hello World!");

Erlang

-module(hello).
-export([hello_world/0]).

hello_world() -> io:fwrite("Hello, World!\n").

Euphoria

puts(1, "Hello, World!")

F

F#

print_endline "Hello, World!"

Factor

"Hello, World!" print

filePro

 @once:
mesgbox "Hello, World!" ; exit

Focal

type "Hello, World!",!

Focus

-TYPE Hello world

Forth

: HELLO ( -- ) ." Hello, World!" CR ;
HELLO

Fortran

 PROGRAM HELLO
PRINT *, 'Hello, World!'
END

Fril

 ?((pp "Hello, World!"))

Frink

println["Hello, World!"]

G

Gambas

PUBLIC SUB Main()
Print "Hello, World!"
END
Graphical:
PUBLIC SUB Main()
Message.Info("Hello, World!")
END

Go

package main
import fmt "fmt"

func main() {
   fmt.Printf("Hello, World!\n");
}

Groovy

println "Hello, World"

Gtk+ in C++

#include <iostream>
#include <gtkmm/main.h>
#include <gtkmm/button.h>
#include <gtkmm/window.h>
using namespace std;

class HelloWorld : public Gtk::Window {
public:
HelloWorld();
virtual ~HelloWorld();
protected:
Gtk::Button m_button;
virtual void on_button_clicked();
};

HelloWorld::HelloWorld()
: m_button("Hello, World!") {
set_border_width(10);
m_button.signal_clicked().connect(SigC::slot(*this,
&HelloWorld::on_button_clicked));
add(m_button);
m_button.show();
}

HelloWorld::~HelloWorld() {}

void HelloWorld::on_button_clicked() {
cout << "Hello, World!" << endl;
}

int main (int argc, char *argv[]) {
Gtk::Main kit(argc, argv);
HelloWorld helloworld;
Gtk::Main::run(helloworld);
return 0;
}

Gtk# in C#

using Gtk;
using GtkSharp;
using System;

class Hello {
static void Main()
{
Application.Init ();

Window window = new Window("");
window.DeleteEvent += cls_evn;
Button close = new Button ("Hello world");
close.Clicked += new EventHandler(cls_evn);

window.Add(close);
window.ShowAll();

Application.Run ();
}
static void cls_evn(object obj, EventArgs args)
{
Application.Quit();
}
}

H

Haskell

module Main (main) where

main = putStrLn "Hello, World!"

Heron

program HelloWorld;
functions {
_main() {
print_string("Hello, World!");
}
}
end

HLA (High Level Assembly)

program helloWorld;
#include("stdlib.hhf")
begin helloWorld;

stdout.put( "Hello World" nl );

end helloWorld;

HP-41, HP-42S

Hewlett-Packard RPN-based alphanumeric engineering calculators.

01 LBLTHELLO
02 THELLO, WORLD
03 PROMPT

HTML

<html>
<body>
Hello, World!
</body>
</html>
HTML 4.01 Strict
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Strict//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Hello, World!</title>
</head>
<body>
<p>Hello, World!</p>
</body>
</html>

HyperTalk

Apple HyperCard's scripting programming language.

put "Hello, World!"

or

Answer "Hello, World!"

I

Icon

# In Icon
procedure main()
write("Hello world")
end

IDL

print,"Hello World!"

Inform

[ Main;
"Hello, World!";
];

Intercal

 IN INTERCAL 
HELLO WORLD

Io

"Hello, World!" print

or

write("Hello, World!\n")

Iptscrae

ON ENTER {
"Hello, " "World!" & SAY
}

J

J

'Hello world'

Java

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

Java byte-code

Disassembler output of javap -c HelloWorld.

public class HelloWorld extends java.lang.Object{
public HelloWorld();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3; //String Hello, World!
5: invokevirtual #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
}

Java Swing

import javax.swing.JOptionPane;

public class Hello
{
public static void main(String[] args)
{
JOptionPane.showMessageDialog(null, "Hello, World!");
}
}

Java SWT

import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Label;
public class SWTHello {
public static void main (String [] args) {
Display display = new Display ();
final Shell shell = new Shell(display);
RowLayout layout = new RowLayout();
layout.justify = true;
layout.pack = true;
shell.setLayout(layout);
shell.setText("Hello, World!");
Label label = new Label(shell, SWT.CENTER);
label.setText("Hello, World!");
shell.pack();
shell.open ();
while (!shell.isDisposed ()) {
if (!display.readAndDispatch ()) display.sleep ();
}
display.dispose ();
}
}

Java applet

Java applets work in conjunction with HTML files.

<HTML>
<HEAD>
<TITLE>Hello world</TITLE>
</HEAD>
<BODY>

HelloWorld Program says:

<APPLET CODE="HelloWorld.class" WIDTH=600 HEIGHT=100>
</APPLET>

</BODY>
</HTML>
import java.applet.*;
import java.awt.*;

public class HelloWorld extends Applet {
public void paint(Graphics g) {
g.drawString("Hello, World!", 100, 50);
}
}

JavaFX Script (F3)

var win = new Frame();
win.title = "Hello World!";
win.width = 400;
var label = new Label();
label.text = "Hello World!";
win.content = label;
win.visible = true;

Visual version:

Stage {   
    title: "Hello World!"    
    width: 320    
    height: 240    
    visible: true  
}   

JavaScript

<script language="JavaScript">
    document.write('Hello, World!');
</script>

or with an alert

alert('Hello, World!');
or
<script type="text/javascript">
function helloWorld()
{
alert("Hello, World!");
}
</script>
<a href="#" onclick="helloWorld(); return false;">Hello World Example</a>

or

<a href="#" onclick="alert('Hello, World!'); return false;">Hello World Example
</a>

Julia

println("Salut le Monde!")

K

K

`0:"Hello world\n"

Kogut

WriteLine "Hello, World!"

L

LaTeX

\documentclass{article}
\begin{document}
Hello, World!
\end{document}

Lisaac

section HEADER
+ name := HELLO_WORLD;
- category := MACRO;
section INHERIT
- parent_object:OBJECT := OBJECT;
section PUBLIC
- make <-
(
"Hello World !\n".print;
);

Lisp

Lisp has many dialects that have appeared over its almost fifty-year history.

Common Lisp

(format t "Hello World!~%")

or

(write-line "Hello World!")

or merely:

 "Hello World!"

Scheme

(display "Hello, World!")

Emacs Lisp

 (print "Hello, World!")

AutoLisp

 (print "Hello, World!")

XLisp

 (print "Hello, World!")

Logo

print [Hello World!]

or

pr [Hello World!]

Lua

print "Hello, World!"

M

M4

Hello, World!

Macsyma, Maxima

print("Hello, World!")$

Maple

>> print("Hello, World!");

Mathematica

(* Hello World in Mathematica *)
Print["Hello world"]

Matlab

disp('Hello world')

Maude

fmod HELLOWORLD is
protecting STRING .
op helloworld : -> String .
eq helloworld = "Hello, World." .
endfm
red helloworld .

Max

max v2;
#N vpatcher 10 59 610 459;
#P message 33 93 63 196617 Hello World!;
#P newex 33 73 45 196617 loadbang;
#P newex 33 111 31 196617 print;
#P connect 1 0 2 0;
#P connect 2 0 0 0;
#P pop;

mIrc Script

echo Hello World

Model 204

BEGIN
PRINT 'Hello, World!'
END

Modula-2

MODULE Hello;

FROM InOut IMPORT WriteLn, WriteString;

BEGIN
WriteString ("Hello, World!");
WriteLn
END Hello.
(* Modula-2 R10 *)  

MODULE Hello; 
IMPORT PervasiveIO;
BEGIN
   WRITE("Hello, World!\n");
END Hello. 

Moo

notify(player, "Hello, World!");

Ms-Dos batch

The @ symbol is optional and prevents the system from displaying the command before executing it.

@echo Hello, World!

Muf

: main
me @ "Hello, World!" notify
;

Mumps

W "Hello, World!"

N

Natural

WRITE "Hello, World!"
END

Nemerle

System.Console.WriteLine("Hello, World!");

NewtonScript

baseview :=
{viewBounds: {left: -3, top: 71, right: 138, bottom: 137},
viewFlags: 581,
declareSelf: 'base,
_proto: protoFloatNGo,
debug: "baseview"
};

textview := * child of baseview *
{text: "Hello World!",
viewBounds: {left: 33, top: 24, right: 113, bottom: 46},
viewFlags: 579,
_proto: protoStaticText,
debug: "textview"
};

Nice

void main(String[] args)
{
println("hello world");
}

Nim

echo "Hello World!"

O

Oberon

MODULE Hello;
IMPORT Out;
BEGIN
Out.String("Hello World!");
Out.Ln
END Hello.

Objective C

Functional C Version

#import <stdio.h>

int main() {
printf( "Hello, World!\n" );
return 0;
}

Object-Oriented C Version

#import <stdio.h>

//An object-oriented version.
@interface Hello : Object
{
const char str[] = "Hello world";
}
- (id) hello (void);
@end

@implementation Hello
- (id) hello (void)
{
printf("%s\n", str);
}
@end

int main(void)
{
Hello *h = [Hello new];
[h hello];

[h free];
return 0;
}

OpenStep/Cocoa Version

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
NSLog(@"Hello, World!");
return 0;
}

OCaml

print_endline "Hello World!"

Occam

#USE "course.lib"

PROC hello.world(CHAN OF BYTE screen!)
out.string("Hello World!*n", 0, screen!)
:

Octave

printf("Hello World\n");

Opl

PROC hello:
PRINT "Hello, world!"
ENDP

Ops5

(object-class request
^action)

(startup
(strategy MEA)
(make request ^action hello)
)

(rule hello
(request ^action hello)
(write |Hello World!| (crlf))
)

Ops83

module hello (main)
{ procedure main( )
{
write() |Hello, World!|, '\n';
};
};

Oz

{Browse 'Hello World!'} 

P

Parrot assembly language

print "Hello, World!\n"
end

Pascal

program hello;

begin
writeln('Hello, World!');
end.

Pdf

%PDF-1.0
1 0 obj
<<
/Type /Catalog
/Pages 3 0 R
/Outlines 2 0 R
>>
endobj
2 0 obj
<<
/Type /Outlines
/Count 0
>>
endobj
3 0 obj
<<
/Type /Pages
/Count 1
/Kids [4 0 R]
>>
endobj
4 0 obj
<<
/Type /Page
/Parent 3 0 R
/Resources << /Font << /F1 7 0 R >>/ProcSet 6 0 R
>>
/MediaBox [0 0 612 792]
/Contents 5 0 R
>>
endobj
5 0 obj
<< /Length 44 >>
stream
BT
/F1 24 Tf
100 100 Td (Hello World) Tj
ET
endstream
endobj
6 0 obj
[/PDF /Text]
endobj
7 0 obj
<<
/Type /Font
/Subtype /Type1
/Name /F1
/BaseFont /Helvetica
/Encoding /MacRomanEncoding
>>
endobj
xref
0 8
0000000000 65535 f
0000000009 00000 n
0000000074 00000 n
0000000120 00000 n
0000000179 00000 n
0000000322 00000 n
0000000415 00000 n
0000000445 00000 n
trailer
<<
/Size 8
/Root 1 0 R
>>
startxref
553
%%EOF

Perl

# Hello
print "Hello, World!\n";

Perl 6

say "Hello world!";

PHP

<?php
echo 'Hello, World!';
?>

or

<?php
print 'Hello, World!' . PHP_EOL;
?>

or

<?='Hello, World!'?>

PHP-GTK

<?php
$wnd = new GtkWindow();
$wnd->set_title('Hello');
$wnd->connect_simple('destroy', array('gtk', 'main_quit'));
$lblHello = new GtkLabel("Hello world!'");
$wnd->add($lblHello);
$wnd->show_all();
Gtk::main();
?>

Pike

int main() {
write("Hello, World!\n");
return 0;
}

Pilot

T:Hello, World!

Pl/Sql

-- start anonymous block
set serveroutput on size 10000000;
begin
dbms_output.enable(1000000);
dbms_output.put_line('Hello World!');
end;
-- end anonymous block

Pl/I

Test: proc options(main) reorder;
put skip edit('Hello, World!') (a);
end Test;

Pop-11

'Hello world' =>

PostScript

% Displays on console.
(Hello World!) =

%!
% Displays as page output.
/Courier findfont
24 scalefont
setfont
100 100 moveto
(Hello World!) show
showpage

Pov-Ray

#include "colors.inc"
camera {
location <3, 1, -10>
look_at <3,0,0>
}
light_source { <500,500,-1000> White }
text {
ttf "timrom.ttf" "Hello World!" 1, 0
pigment { White }
}

Processing

println("Hello, World!");

Profan

' Hello in Profan 
cls
print "Hello World!"
waitkey

Progress

message "Hello World" view-as alert-box.

Prolog

:- write('Hello world'),nl.

Protocol Buffers

message hello
{
required string data = 1 [default="Hello World!"];
}

PureBasic

; In PureBasic console
OpenConsole()
ConsoleTitle ("Hello World!")
PrintN ("Hello World!")
CloseConsole()

Python 2

print "Hello, World!" 

Python 3

print("Hello, World!") 

Q

QML

Text {          
     text: "Hello World!"          
} 

Qt toolkit (C++)

#include <QApplication>
#include <QLabel>

int main(int argc, char *argv[])
{
  QApplication app(argc, argv);
  QLabel salut("Hello World!");
  salut.show();
  return app.exec();
}

QuakeC

bprint("Hello World\n");

QuickBasic

REM Hello World in QuickBASIC
PRINT "Hello World!"
END

R

R

cat("Hello world\n")

Ratfor

print *, 'hello, world'
end

RealBasic

' Hello
msgBox "Hello World!"

Rebol

print "Hello, World!"

Refal

$ENTRY GO{=<Prout 'Hello, World!'>;}

Rexx, ARexx, NetRexx, and Object REXX

say "Hello, World!"
or, Windows:
call RxFuncAdd 'SysLoadFuncs', 'RexxUtil', 'SysLoadFuncs'
call SysLoadFuncs
call RxMessageBox 'Hello World!', 'Hello World Window', 'OK', 'EXCLAMATION'
exit

Rpg

Free-Form Syntax

 /FREE
DSPLY 'Hello, World!';
*InLR = *On;
/END-FREE

Traditional Syntax

 d TestMessage 
c Const( 'Hello, World!' )
c TestMessage DSPLY
c EVAL *InLR = *On

Rpg Code

Message Window

mwin("Hello, World!")
wait()

On Screen Text

text(1,1"Hello, World!")
wait()

RPL (HP calculators)

<<
     CLLCD
     "Hello, World!" 1 DISP
     0 WAIT
     DROP
   >>

Rsl

[Hello World!];

Rtf

{\rtf1\ansi\deff0
{\fonttbl {\f0 Courier New;}}
\f0\fs20 Hello, World!
}

Ruby

puts "Hello, World!"

Rust

io::println("hello?");

S

S

cat("Hello world\n")

Sas

data _null_;
put 'Hello, World!';
run;

Sather

class HELLO_WORLD is
main is
#OUT+"Hello world\n";
end;
end;

Scala

object HelloWorld with Application {
Console.println("Hello, World!");
}

Scriptol

 print "Hello World!"

sed

sed -ne '1s/.*/Hello, World!/p'

Seed7

$ include "seed7_05.s7i";

const proc: main is func
begin
writeln("Hello, World!");
end func;

Self

'Hello, World!' print.

Setl

-- Hello in Setl2

procedure Hello();
print "Hello World!";
end Hello;

Scheme

 (display "Hello world!")
 (newline)

Simula

Begin
OutText("Hello, World!");
OutImage;
End

Smalltalk

Transcript show: 'Hello, World!'; cr
Graphical:
('Hello, World!' asMorph openInWindow) submorphs second color: Color black

Smil

<!-- Hello World in SMIL -->
<smil>
<head>
<layout>
<root-layout width="300" height="160" background-color="white"/>
<region id="text_region" left="115" top="60"/>
</layout>
</head>
<body>
<text src="data:,Hello%20World!" region="text_region">
<param name="fontFace" value="Arial"/>
</text>
</body>
</smil>

Sml

print "Hello, World!\n";

Snobol

 OUTPUT = "Hello, World!"
END

Span

class Hello {
static public main: args {
Console << "Hello, World!\n";
}
}

Spark

with Spark_IO;
--# inherit Spark_IO;
--# main_program;

procedure Hello_World
--# global in out Spark_IO.Outputs;
--# derives Spark_IO.Outputs from Spark_IO.Outputs;
is
begin
Spark_IO.Put_Line (Spark_IO.Standard_Output, "Hello, World!", 0);
end Hello_World;

Spitbol

 OUTPUT = "Hello, World!"
END

Spss Syntax

ECHO "Hello, World!".

Sql

CREATE TABLE message (text char(15));
INSERT INTO message (text) VALUES ('Hello, World!');
SELECT text FROM message;
DROP TABLE message;

MySQL or PostgreSQL:

SELECT 'Hello, World!';

Starlet

RACINE: HELLO_WORLD.
NOTIONS:
HELLO_WORLD : ecrire("Hello, World!").

SuperCollider

"Hello World".postln;

SVG

<?xml version="1.0" encoding="utf-8" standalone="no"?>
<svg width="240px" height="100px" viewBox="0 0 240 100" xmlns="">
<title>Hello World</title>
<g>
<text x="20" y="50">Hello World!</text>
</g>
</svg>

Swift

println("Hello World!")

T

Tacl

?TACL HELLO
#OUTPUT Hello, World!

Tcl

puts "Hello, World!"

Teco

!Hello in TECO
FTHello World$

TeX

Hello world
\bye

Ti-Basic

10 REM Hello World in TI BASIC
20 REM for the TI99 series computer
100 CALL CLEAR
110 PRINT "HELLO WORLD"
120 GOTO 120

Tk

label .l -text "Hello World!"
pack .l

Turing

put "Hello, World!"

U

Unix shell

echo 'Hello, World!'

or using an inline 'here document'

cat <<'DELIM'
Hello, World!
DELIM

or

printf '%s' $'Hello, World!\n'

or for a curses interface:

dialog --msgbox 'Hello, World!' 0 0

UnrealScript

class HelloHUD extends HudBase;

simulated function DrawHudPassC (Canvas C)
{
C.SetPos( 0.50*C.ClipX , 0.50*C.ClipY);
C.DrawText("Hello World!");
}

defaultproperties
{
}

V

Verilog

module main;

initial
begin
$display("Hello, World");
$finish ;
end

endmodule

VHDL

use std.textio.all;

ENTITY hello IS
END ENTITY hello;

ARCHITECTURE Scriptol OF hello IS
CONSTANT message : string := "hello world";
BEGIN
PROCESS
variable L: line;
BEGIN
write(L, message);
writeline(output, L);
wait;
END PROCESS;
END ARCHITECTURE Scriptol;

Visual Basic .Net 2003

If the code is entered as part of a Form subclass:
Private Sub frmForm_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyBase.Load
MessageBox.Show("Hello World!", "HELLO WORLD")
Me.Close()
End Sub
Traditional Visual Basic code:
Public Class MyApplication
Shared Sub Main()
MessageBox.Show("Hello World!", "HELLO WORLD")
End Sub
End Class

Visual DialogScript

info Hello world!

Visual Prolog console program

#include @"pfc\console\console.ph"

goal
console::init(),
stdio::write("Hello, World!").

Vms

$ WRITE SYS$OUTPUT "Hello World!"

Vmrl

Shape
{
geometry Text
{string "Hello World!"}
}

W

Windows api (in C)

#include <windows.h>
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine,
int nCmdShow)
{
MessageBox(NULL, "Hello, World!", "", MB_OK);
return 0;
}

WebAssembly

The following C program is compiled to WebAssemby's S-Expression:

#include <stdio.h>
    
int main() {
  puts("Hello...");
}

hello.wat:

(module
(type $FUNCSIG$ii (func (param i32) (result i32)))
(import "env" "puts" (func $puts (param i32) (result i32)))
(table 0 anyfunc)
(memory $0 1)
(data (i32.const 16) "Hello...\00")
(export "memory" (memory $0))
(export "main" (func $main))
(func $main (; 1 ;) (result i32)
(drop
(call $puts
(i32.const 16)
)
)
(i32.const 0)
)
)

Wscript

WScript.Echo("Hello World!"); 

X

X++

class classHello
{
}

static void main(args Args)
{
dialog dialog;
dialog = new dialog();
dialog.addText("Hello World!");
dialog.run();
}

XAML/WPF

<Page xmlns="">
<TextBlock>Hello, World!</TextBlock>
</Page>

XHTML 1.1

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN">
<html xmlns="" xml:lang="en">
<head>
<title>Hello</title>
</head>
<body>
<p>Hello, World!</p>
</body>
</html>

XML

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="HelloWorld.xsl" ?>
<!-- Hello in XML -->
<text>
   <string>Hello, World!</string>
</text>

XQuery

(: Hello with XQuery :)
let $i := "Hello World!"
return $i

XSLT

Simplest code:

<xsl:template match="/">
<xsl:text>Hello, World!</xsl:text>
</xsl:template>

Generated HTML:

 <xsl:template match="/">
<html>
<body>
<h1>Hello, World!</h1>
</body>
</html>
</xsl:template>

XUL

<?xml-stylesheet href="chrome://global/skin" type="text/css" ?>
<window xmlns="" align="center" pack="center" flex="1">
<description>Hello, World!</description>
</window>

Submit more listings in comments.

Created in 2006. Last modified September 6, 2021
This page is free to print and copy for any usage. Don't use it on another website (duplicate content): put a link on this page instead.