List of Hello world program examples

The Hello world program is a simple computer program that prints (or displays) the string "Hello, world!" or some variant thereof. It is typically one of the simplest programs possible in almost all computer languages, and often used as first program to demonstrate a programming language. As such it can be used to quickly compare syntax differences between various programming languages. The following is a list of canonical hello world programs in 91 programming languages.

A

ABAP

REPORT HELLOWORLD.
WRITE 'Hello World'.

ActionScript 3.0

trace ("Hello, world!");

or (if you want it to show on the stage)

package com.example
{
    import flash.text.TextField;
    import flash.display.Sprite;

    public class Greeter extends Sprite
    {
        public function Greeter()
        {
            var txtHello:TextField = new TextField();
            txtHello.text = "Hello, world!";
            addChild(txtHello);
        }
    }
}

Ada

with Ada.Text_IO;

procedure Hello_World is
 use Ada.Text_IO;
begin
    Put_Line("Hello, world!");
end;

Adventure Game Studio Script

Display("Hello, world!");

or (if you want to draw it to the background surface)

DrawingSurface *surface = Room.GetDrawingSurfaceForBackground();
surface.DrawString(0, 100, Game.NormalFont, "Hello, world!");
surface.Release();

ALGOL

BEGIN
   DISPLAY ("Hello, world!");
END.

ALGOL 68

print("Hello, world!")

Amiga E

PROC main()
   WriteF('Hello, world!')
ENDPROC

APL

⎕←'Hello world!'

Assembly Language — MOS Technology 6502, CBM KERNEL

 A_CR  = $0D              ;carriage return
 BSOUT = $FFD2            ;kernel ROM sub, write to current output device
 ;
         LDX #$00         ;starting index in .X register
 ; 
 LOOP    LDA MSG,X        ;read message text
         BEQ LOOPEND      ;end of text
 ;
         JSR BSOUT        ;output char
         INX
         BNE LOOP         ;repeat
 ;
 LOOPEND RTS              ;return from subroutine
 ;
 MSG     .BYT 'Hello, world!',A_CR,$00

Assembly language – x86 DOS

; The output file is 22 bytes.
; 14 bytes are taken by "Hello, world!$
;
; Written by Stewart Moss - May 2006
; This is a .COM file so the CS and DS are in the same segment
;
; I assembled and linked using TASM
;
; tasm /m3 /zn /q hello.asm
; tlink /t hello.obj

.model tiny
.code
org 100h

main  proc

      mov    ah,9                       ; Display String Service
      mov    dx,offset hello_message    ; Offset of message (Segment DS is the right segment in .COM files)
      int    21h                        ; call DOS int 21h service to display message at ptr ds:dx

      retn                              ; returns to address 0000 off the stack 
                                        ; which points to bytes which make int 20h (exit program)

hello_message db 'Hello, world!$'

main  endp
end   main

Assembly language – x86 Windows 32-bit

; This program displays "Hello, World!" in a windows messagebox and then quits.
;
; Written by Stewart Moss - May 2006
;
; Assemble using TASM 5.0 and TLINK32
;
; The output EXE is standard 4096 bytes long.
; It is possible to produce really small windows PE exe files, but that
; is outside of the scope of this demo.
         
         .486p
         .model  flat,STDCALL
include  win32.inc

extrn            MessageBoxA:PROC
extrn            ExitProcess:PROC

.data

HelloWorld db "Hello, world!",0
msgTitle db "Hello world program",0

.code
Start:
         push    MB_ICONQUESTION + MB_APPLMODAL + MB_OK
         push    offset msgTitle
         push    offset HelloWorld
         push    0
         call    MessageBoxA
         
         push 0
         call ExitProcess
ends
end Start

Assembly language – x86-64 Linux, AT&T syntax

    .section    .rodata
string:
    .ascii "Hello, world!\n\0"
length:
    .quad . -string     #Dot = 'here'

    .section    .text
    .globl _start       #Make entry point visible to linker
_start:
    movq $4, %rax       #4=write
    movq $1, %rbx       #1=stdout
    movq $string, %rcx
    movq length, %rdx
    int $0x80       #Call Operating System
    movq %rax, %rbx     #Make program return syscall exit status
    movq $1, %rax       #1=exit
    int $0x80       #Call System Again

Assembly language – Z80


 EQU CR    = #0D          ; carriage return
 EQU PROUT = #xxxx        ; character output routine
 ;
         LD  HL,MSG       ; Point to message
 ; 
 PRLOOP  LD  A,(HL)       ; read byte from message
         AND A            ; set zero flag from byte read
         RET Z            ; end of text if zero
         JSR PROUT        ; output char
         INC HL           ; point to next char
         JR  PRLOOP       ; repeat
 ;
 MSG     DB  "Hello, world!",CR,00
 ;

AutoHotkey

Msgbox, Hello, world!

Traytip,, Hello, world!

AutoIt

Msgbox(64, "", "Hello, world!")

AWK

BEGIN { print "Hello, world!" }

B

BASIC

PRINT "Hello, world!"

Batch File

@echo Hello, world!

BCPL

GET "LIBHDR"
LET START() BE
$(
  WRITES("Hello, world!*N")
$)

brainfuck

+++++ +++++             initialize counter (cell #0) to 10
[                       use loop to set the next four cells to 70/100/30/10
    > +++++ ++              add  7 to cell #1
    > +++++ +++++           add 10 to cell #2 
    > +++                   add  3 to cell #3
    > +                     add  1 to cell #4
    <<<< -                  decrement counter (cell #0)
]                   
> ++ .                  print 'H'
> + .                   print 'e'
+++++ ++ .              print 'l'
.                       print 'l'
+++ .                   print 'o'
> ++ .                  print ' '
<< +++++ +++++ +++++ .  print 'W'
> .                     print 'o'
+++ .                   print 'r'
----- - .               print 'l'
----- --- .             print 'd'
> + .                   print '!'
> .                     print '\n'

C

#include <stdio.h>

int main(int argc, char *argv[])
{
    printf("Hello, world!\n");

    return 0;
}

C++

#include <iostream>
using namespace std;
int main()
{
    cout << "Hello, world!" << endl;
    return 0;
}

C#

using System;
class Program
{
    public static void Main()
    {
        Console.WriteLine("Hello, world!");
        Console.ReadKey(true);
    }
}

Casio BASIC

"HELLO, WORLD!"

Common Intermediate Language

.assembly Hello {}
.assembly extern mscorlib {}
.method static void Main()
{
    .entrypoint
    .maxstack 1
    ldstr "Hello, world!"
    call void [mscorlib]System.Console::WriteLine(string)
    call string[mscorlib]System.Console::ReadKey(true)
    pop
    ret
}

ColdFusion Markup Language (CFML)

CF Script:

<cfscript>
    variables.greeting = "Hello, world!";
    WriteOutput( variables.greeting );
</cfscript>

CFML Tags:

<cfset variables.greeting = "Hello, world!">
<cfoutput>#variables.greeting#</cfoutput>

Clojure

Console version:

(println "Hello, world!")

GUI version:

(javax.swing.JOptionPane/showMessageDialog nil "Hello, world!")

COBOL

       IDENTIFICATION DIVISION.
       PROGRAM-ID. HELLO-WORLD.
       PROCEDURE DIVISION.
           DISPLAY 'Hello, world!'.
           STOP RUN.

D

import std.stdio;

void main()
{
  writeln("Hello, world!");
}

Dart

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

DCL

WRITE SYS$OUTPUT "Hello, world!"

Delphi

{$APPTYPE CONSOLE}
begin
  Writeln('Hello, world!');
end.

E

Erlang

io:format("~s~n", ["Hello, world!"])

F

F#

printfn "Hello, world!"

Falcon

 printl( "Hello, world!" )

 > "Hello, world!"

Forth

." Hello, world! "

Fortran

(Fortran 95 and later)

program hello
    write (*,*) 'Hello, world!'
end program hello

(Fortran 90 )

program hello
   print *, 'Hello, world!'
end program hello

OR (FORTRAN 77 and prior)

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

G

Game Maker Language

str='Hello, world!'
//Using the show_message() function:
show_message(str);
//Using the draw_text() function:
draw_text(0,0,str);

Go

package main

import "fmt"

func main() {
   fmt.Println("Hello, world!")
}

Groovy

println "Hello, world!"

H

Haskell

main = putStrLn "Hello, world!"

HOP

(define-service (hello-world)
  (<HTML>
     (<HEAD>
    (<TITLE> "Hello, world!"))
     (<BODY>
    "Hello, world!")))

HTML

<!DOCTYPE html>
<html>
<body>
Hello, world!
</body>
</html>

I

IDL

print, "Hello, world!"
end

Io

 "Hello, world!" println

ISLISP

(format (standard-output) "Hello, world!")

J

'Hello, world!'

Java

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

JavaScript

To write to an HTML document:

document.write('Hello, world!');

To display an alert dialog box:

alert('Hello, world!');

To write to a console/debugging log:

console.log('Hello, world!');

Using Mozilla's Rhino:

print('Hello, world!');

Using Windows Script Host:

WScript.Echo("Hello, world!");

K

Kotlin

package hello

fun main(args : Array<String>) {
  println("Hello, world!")
}

L

Lisp

(princ "Hello, world!")

LScript (LSL)

default
{
    state_entry()
    {
        llSay(0, "Hello, World!");
    }
}

Logo

print [Hello, world!]

Lua

print("Hello, World!")

M

M4

Hello, world!

Malbolge

('&%:9]!~}|z2Vxwv-,POqponl$Hjig%eB@@>}=<M:9wv6WsU2T|nm-,jcL(I&%$#"
`CB]V?Tx<uVtT`Rpo3NlF.Jh++FdbCBA@?]!~|4XzyTT43Qsqq(Lnmkj"Fhg${z@>

Mathematica

Print["Hello, world!"]

Maple

print(`Hello, world!`);

MATLAB

disp('Hello, world!')

Medved

Medved-Rict(Veta(Kratka(!ZubniKaz(OTEVRITPUSU<Hello, world!>ZAVRITPUSU)))) pak Medved-Sednout

Medved++

import Medved.*;
import Les.zimnispanek;
public: declare - string helloWorld = "Hello, World!";
startFunction HelloWorld(){
MedvedVzbudit();
performAction - Medved.zarvat(helloWorld);
}
function MedvedVzbudit(){
endAction - Les.zimnispanek;
performAction - Medved.vzbuditse;
performAction - Medved.cekat(HelloWorld);
performAction - Medved.sednout;
performAction - Medved.cekat(5s);
performAction - Medved.spat;
startAction - Les.zimnispanek;
}

Medved RSS Edition (Rohlik Se Salamem)

cntM _ po
    0 S &s1 <Hello, world!>
0

mIRC Script

echo -a Hello, world!

MUMPS

main()
 write "Hello, world!"
 quit

O

Oberon

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

Obix

system.console.write_line ( "Hello, world!" )

Objective-C

#import <stdio.h>
int main(void)
{
    printf("Hello, world!\n");
    return 0;
}

Otherwise (by gcc on pre-OpenStep/Apple Object based runtime):

#import <stdio.h>
#import <objc/Object.h>
@interface Hello: Object
- (void) say;
@end
@implementation Hello
- (void) say {
  printf("Hello, world!\n");
}
@end
int main() {
  Hello *hello = [Hello new];
  [hello say];
  [hello free];
  return 0;
}

Pre-Modern (post-1994 OpenStep based Foundation APIs:

@interface Hello:NSObject
- (void) say;
@end
@implementation Hello
- (void) say {
   NSLog(@"Hello, world!");
}
@end
int main(int argc, char *argv[])
{
    NSAutoreleasePool *p = [[NSAutoreleasePool alloc] init];
    Hello *hello = [Hello new];
    [hello say];
    [hello release];
    [p release];
    return 0;
}

Modern (llvm, ARC memory management):

@interface Hello:NSObject
- (void) say;
@end
@implementation Hello
- (void) say {
   NSLog(@"Hello, world!");
}
@end
int main(int argc, char *argv[])
{
    @autoreleasepool {;
        [[Hello new] say];
    }
    return 0;
}

OCaml

 print_endline "Hello, world!"

Opa

A "hello world" web server:

Server.start(Server.http, 
    { title: "Hello, world!", 
      page: function() { <>Hello, world!</> } })

Oriel

MessageBox(OK, 1, INFORMATION, "Hello, world!", "Oriel Says Hello", ResponseValue)

P

Pascal

program HelloWorld;
uses crt;

begin
  WriteLn('Hello, world!');
end.

Pawn

main()
{
    print("Hello, world.");
}

Perl 5

print "Hello, world!";

use v5.10;
say 'Hello, world!';

PHP

<?php echo 'Hello, world!' ?>

<?php print 'Hello, world' ?>

<?= 'Hello, world!' ?>

PL/SQL

SET SERVEROUTPUT ON;
BEGIN
    DBMS_OUTPUT.PUT_LINE('Hello, world!');
END;

PowerShell

Write-Host "Hello, world!"

Prolog

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

Python 2

print "Hello, world!"

Python 3

print("Hello, world!")

Pythonect

"Hello, world!" -> print

R

cat('Hello, world!\n')

Racket

Trivial "hello world" program:


"Hello, world!"

Running this program produces "Hello, World!". More direct version:

#lang racket
(display "Hello, world!")

A "hello world" web server using Racket's web-server/insta language:

 
#lang web-server/insta
(define (start request) (response/xexpr '(html (body "Hello, world"))))}

REXX

say Hello, world!

RPL

<< "Hello, world!" MSGBOX >>

RTL/2

TITLE Hello, world!;
LET NL=10;
EXT PROC(REF ARRAY BYTE) TWRT;
ENT PROC INT RRJOB();
    TWRT("Hello, world!#NL#");
    RETURN(1);
ENDPROC;

Ruby

puts "Hello, world!"

Rust

fn main() {
  io::println("Hello, world!");
}

S

S-APL

{sapl:I sapl:do java:ubiware.shared.PrintBehavior} sapl:configuredAs {p:print sapl:is "Hello, world!"} .

Scala

object HelloWorld extends App {
  println("Hello, world!")
}

Scheme

(display "Hello, world!")

Shell

echo Hello, world!

Simula

Begin
OutText ("Hello, world!");
Outimage;
End;

Smalltalk

Transcript show: 'Hello, world!'.

SNOBOL

  OUTPUT = 'Hello, world!'
END

Speakeasy

As an interactive statement :

"Hello, world!"

As a program :

program hello
   "Hello, world!"
end

SQL

SELECT 'Hello, world!' FROM DUMMY; -- DUMMY is a standard table in SAP HANA.
SELECT 'Hello, world!' FROM DUAL; -- DUAL is a standard table in Oracle.
SELECT 'Hello, world!' -- This will work in SQL Server.

Smalltalk

Transcript show: 'Hello, world!'.

Stata

display "Hello, world!"

T

Tcl

puts "Hello, world!"

TI-BASIC

Disp "Hello, world!"

U

UnrealScript

Log("Hello, world!");

V

Vala

void main ()
{
    print ("Hello, world!\n");
}

Visual Basic

 MsgBox "Hello, world!"

Visual Basic .NET

Module Module1
    Sub Main() 
        Console.WriteLine("Hello, world!")
    End Sub
End Module
'non-console example:
Class Form1
    Public Sub Form1_Load(ByVal sender As Object, ByVal e As EventArgs) Handles Me.Load()
        MsgBox("Hello, world!")
    End Sub
End Class

W

Whitespace

This example shows the program with syntax highlighting. Without highlighting, it would appear to be blank space.
S S S T S S T S S S L T L S S S S S T T S S T S T L T L S S S S S T T S T T S S L T L S S S S S T T S T T S S L T L S S S S S T T S T T T T L T L S S S S S T S T T S S L T L S S S S S T S S S S S L T L S S S S S T T T S T T T L T L S S S S S T T S T T T T L T L S S S S S T T T S S T S L T L S S S S S T T S T T S S L T L S S S S S T T S S T S S L T L S S S S S T S S S S T L T L S S L L L

External links

Nodewave's computer language comparison, examples implementing the same loop algorithm I will not throw paper airplanes in class.
Rosetta Code hello world listing, hello world examples for 230 programming languages.

de:Liste von Hallo-Welt-Programmen/Höhere Programmiersprachen es:Anexo:Ejemplos de implementación del «Hola mundo» fr:Liste de programme Hello world ja:Hello worldプログラムの一覧 nl:Hello_world_(programma) zh:Hello World程序样例

🪦 Wikipedia History

6.5 yearsage

1editors

1edits

Archive Provenance

Created: February 3, 2013

Deleted: December 28, 2019

Article size: 32.0 KB

Technical Metadata

Wikipedia page ID: 29592320

Metadata captured: May 9, 2026 11:02 AM

Metadata updated: May 9, 2026 11:02 AM

Subject Tags

Computer programming

Maintenance Categories

View maintenance categories (15)

Articles with example AWK codeArticles with example C codeArticles with example C Sharp codeArticles with example C++ codeArticles with example D codeArticles with example Fortran codeArticles with example Haskell codeArticles with example Java codeArticles with example JavaScript codeArticles with example Pascal codeArticles with example Perl codeArticles with example Python codeArticles with example Racket codeArticles with example Ruby codeArticles with example Scala code

In Other Languages (6)

de es fr ja nl zh

View language edition titles

de · Liste von Hallo-Welt-Programmen/Höhere Programmiersprachen

es · Anexo:Ejemplos de implementación del «Hola mundo»

fr · Liste de programme Hello world

ja · Hello worldプログラムの一覧

nl · Hello world (programma)

zh · Hello World程序样例

Why Deleted

AfD

by Cryptic

G4: Recreation of a page that was deleted per a deletion discussion: Articles for deletion/List of Hello world program examples

View AfD discussion ↗

Sources

http://rosettacode.org/wiki/Hello_world/Text

www.nodewave.com/...

Archive Inventory

View stored source record counts

Revision rows stored: 0

Outgoing links stored: 9

External links stored: 2

Templates stored: 4

Talk exports stored: 0

AfD exports stored: 0

Raw API payloads stored: 0

Image records stored: 0

View full source metadata

Outgoing Wikipedia links (9)

Alert dialog boxCanonical formComputer programHello world programKernalRhino (JavaScript engine)Syntax (programming languages)Web serverWindows Script Host

External links (2)

http://rosettacode.org/wiki/Hello_world/Text

www.nodewave.com/...

Templates (4)

DEFAULTSORT:Hello World program examplesIncomplete listMainToc