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 109 programming languages.

A

ABAP

Main article: ABAP

REPORT ZHELLOWORLD.
WRITE 'Hello, world!'.

ActionScript 3.0

Main article: ActionScript

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

Main article: Ada (programming language)

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

Adventure Game Studio Script

Main article: Adventure Game Studio

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

Main article: ALGOL

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

ALGOL 68

Main article: ALGOL 68

print("Hello, world!")

Amiga E

Main article: Amiga E

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

APL

Main article: APL (programming language)

'Hello, world!'

AppleScript

Main article: AppleScript

display dialog "Hello, world!"

or if you want a button to trigger the dialog:

on helloWorld()
  display dialog "Hello, world!"
end helloWorld
 
helloWorld()

Assembly language — MOS Technology 6502, Apple II (II+, IIe, IIC)

Main article: Assembly language

; Uses S-C Assembler variant.
; .or is origin
; .as is ASCII String
; .hs is Hex String
        .or $300
main    ldy #$00
.1      lda str,y
        beq .2
        jsr $fded ; ROM routine, COUT, y is preserved
        iny
        bne .1
.2      rts
str     .as "HELLO WORLD"
        .hs 0D00

Assembly language — MOS Technology 6502, Acorn MOS

Main article: Assembly language

100 REM Hello World using a mix of BBC Basic and 6502 assembler 
110 $&A200 = "!dlrow olleH"
115 code% = &A100
120 str = &A200
130 oswrch = &FFEE
140 FOR pass%=0 TO 3 STEP 3
150 P% = code%
160 [ 
170 OPT pass%
180 .START LDY 11
190 CLC
200 .LOOP
210 LDA str,Y
220 JSR oswrch
230 DEY
240 BCC LOOP
250 LDA 13
260 JSR oswrch
270 RTS
280 ]
290 NEXT
300 CALL code%

Assembly language — ARM, BBC BASIC inline assembler

Main article: Assembly language

1000 REM Hello World using a mix of BBC Basic and ARM assembler 
1010 DIM org 100
1020 OS_Write0 = &2
1030 FOR pass=0 TO 3 STEP 3
1040 PROCasm(pass,org)
1050 NEXT pass
1060 CALL org
1070 END
1080 
2000 DEF PROCasm(pass,org)
2010 P%=org
2020 [ OPT pass
2030 ADR    R0, message
2040 SWI    OS_Write0
2050 MOV    PC, R14
2060 .message
2070 EQUS   "Hello, World!" + CHR$(0)
2080 ALIGN
2090 ]
2100 ENDPROC

Assembly language — MOS Technology 6502, CBM KERNAL

Main article: Assembly language

 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

Main article: Assembly language

; 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

Main article: Assembly language

; 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

Main article: Assembly language

	.section	.rodata
string:
	.ascii "Hello, world!\n"
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

Main article: Assembly language

 CR      EQU  $0D          ; carriage return
 PROUT   EQU  $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
         CALL PROUT         ; output char
         INC  HL            ; point to next char
         JR   PRLOOP        ; repeat
 ;
 MSG     DB   "Hello, world!",CR,0
 ;

For TI 83, TI 83+, TI 83+SE, TI 84+, and TI 84+SE calculators:

.NOLIST
#include "ti83plus.inc"
.LIST
     .org $9D93
      .db $BB,$6D
      ld a,0           ; load the value 0 to register a, the ''accumulator''
      ld ($844C),a    ; assign the contents of register a to memory address (CURCOL) in the RAM
      ld ($844B),a    ; assign the contents of register a to memory address (CURROW) in the RAM
      ld hl,text       ; load the data in label "text" to register hl
      rst $28
     .dw $450A    ; calls a function in ti83plus.inc to print text
      rst $28
     .dw $452E ; calls a function in ti83plus.inc to insert a lnbreak (for legibility)
      ret              ; returns from the program to the calc's OS
text:
      .db "Hello, World",0
.end
end

And in pure hex:

219F9D
EF0A45
EF2E45
C9
48692100

AutoHotkey

Main article: AutoHotkey

Msgbox, Hello, world!

Traytip,, Hello, world!

AutoIt

Main article: AutoIt

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

AWK

Main article: AWK

BEGIN { print "Hello, world!" }

B

BASIC

Main article: BASIC

PRINT "Hello, world!"

Batch File

Main article: Batch file

@echo Hello, world!

BCPL

Main article: BCPL

GET "LIBHDR"

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

BennuGD

Main article: BennuGD

 
import "mod_say"
 
Process Main()
Begin 
    say("Hello World!");
End

Befunge

Main article: Befunge

>25*"!dlrow ,olleH":v
                 v:,_@
                 >  ^

brainfuck

Main article: brainfuck

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

C

C

Main article: C (programming language)

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

C++

Main article: C++

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

or

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

or

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

C++/CLI

Main article: C++/CLI

using namespace System;
 
int main(array<System::String ^> ^args)
{
    Console::WriteLine(L"Hello World");
    return 0;
}

C++/CX

Main article: C++/CX

#include "stdafx.h"
#using <Platform.winmd>
using namespace Platform;
 
[MTAThread]
int main(Array<String^>^ args)
{
    String^ message("Hello World!");
    Details::Console::WriteLine(message);}

C#

Main article: C# (programming language)

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

Casio BASIC

Main article: Casio BASIC

"HELLO, WORLD!"

Ceylon

Main article: Ceylon (programming language)

void hello() {
    print("Hello, World!");
}

CoffeeScript

Main article: CoffeeScript

To display an alert dialog box:

alert 'Hello, world!'

To write to a console/debugging log:

console.log 'Hello, world!'

COMAL-80

Main article: COMAL

10 PRINT "Hello, world!"

Common Intermediate Language

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

Main articles: ColdFusion Markup Language and ColdFusion

CF Script:

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

CFML Tags:

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

Clojure

Main article: Clojure

Console version:

(println "Hello, world!")

GUI version:

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

COBOL

Main article: COBOL

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

D

D

Main article: D (programming language)

import std.stdio;
 
void main()
{
  writeln("Hello, world!");
}

Dart

Main article: Dart (programming language)

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

DCL

Main article: DIGITAL Command Language

WRITE SYS$OUTPUT "Hello, world!"

Delphi

Main articles: Object Pascal and Embarcadero Delphi

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

E

E

<'
    extend sys {
        run() is also {
            out("Hello, World!");
        };
    };
'>

Emacs Lisp

Main article: Emacs Lisp

(message "Hello, World!")

Euphoria

Main article: Euphoria (programming language)

puts(1,"Hello World")

Erlang

Main article: Erlang (programming language)

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

F

F#

Main article: F Sharp (programming language)

printfn "Hello, world!"

Falcon

Main article: Falcon (programming language)

 printl( "Hello, world!" )

or

 > "Hello, world!"

Forth

Main article: Forth (programming language)

." Hello, world! "

Fortran

Main article: Fortran

Fortran 90 and later:

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

OR

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

FORTRAN 77 and prior; also accepted in Fortran 90 and later:

       PROGRAM HELLO
       WRITE(*,*) 'Hello, world!'
       END

OR

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

Frost

import "io.frost";
 
main:args {
    [print string:"Hello, world!\n" format:{}];
}

G

Go

Main article: Go (programming language)

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

Groovy

Main article: Groovy (programming language)

println "Hello, world!"

H

Haskell

Main article: Haskell (programming language)

main = putStrLn "Hello, world!"

Haxe

Main article: Haxe

class Main {
    static function main() {
        trace("Hello, world!");
    }
}

HOP

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

I

IDL

Main article: IDL (programming language)

print, "Hello, world!"
end

INTERCAL

Main article: INTERCAL

DO ,1 <- #13
PLEASE DO ,1 SUB #1 <- #238
DO ,1 SUB #2 <- #108
DO ,1 SUB #3 <- #112
DO ,1 SUB #4 <- #0
DO ,1 SUB #5 <- #64
DO ,1 SUB #6 <- #194
DO ,1 SUB #7 <- #48
PLEASE DO ,1 SUB #8 <- #22
DO ,1 SUB #9 <- #248
DO ,1 SUB #10 <- #168
DO ,1 SUB #11 <- #24
DO ,1 SUB #12 <- #16
DO ,1 SUB #13 <- #162
PLEASE READ OUT ,1
PLEASE GIVE UP

Io

Main article: Io (programming language)

 "Hello, world!" println

ISLISP

Main article: ISLISP

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

J

J

Main article: J (programming language)

  'Hello, world!'

Java

Main article: Java (programming language)

In console:

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

or in window with Swing:

import javax.swing.JFrame;  //Importing class JFrame
import javax.swing.JLabel;  //Importing class JLabel
public class HelloWorld {
	public static void main(String[] args) {
		JFrame frame = new JFrame();           //Creating frame
		frame.setTitle("Hi!");                 //Setting title frame
		frame.add(new JLabel("Hello, world!"));//Adding text to frame
		frame.pack();                          //Setting size to smallest
		frame.setLocationRelativeTo(null);     //Centering frame
		frame.setVisible(true);                //Showing frame
	}
}

or in dialog:

import javax.swing.JOptionPane;
public class HelloWorld {
	public static void main(String[] args) {
		JOptionPane.showMessageDialog(null, "Hello, world!");
	}
}

JavaScript

Main article: JavaScript

To write to a console/debugging log:

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

To display an alert dialog box:

alert('Hello, world!');

To write to an HTML document:

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

Using Mozilla's Rhino:

print('Hello, world!');

Julia

  println("Hello world!")

L

Linden Scripting Language

Main article: Linden Scripting Language

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

Lisp

Main article: Lisp (programming language)

(princ "Hello, world!")

Logo

Main article: Logo (programming language)

print [Hello, world!]

LOLCODE

Main article: LOLCODE

HAI
CAN HAS STDIO?
VISIBLE "HAI WORLD!"
KTHXBYE

Lua

Main article: Lua (programming language)

print("Hello, world!")

M

M4

Main article: M4 (computer language)

Hello, world!

Malbolge

Main article: Malbolge

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

Mathematica

Main article: Mathematica

Print["Hello, world!"]

Maple

Main article: Maple (software)

print(`Hello, world!`);

MATLAB

Main article: MATLAB

disp('Hello, world!')

Miranda

Main article: Miranda (programming language)

mira helloWorld.m
|| Start the editor
/edit
|| Type the following text
output = "Hello, world!\n"
|| Save and quit the Editor e.g.  <Esc>:x  
|| then enter at the "Miranda" prompt:
output
/quit

mIRC Script

Main article: mIRC scripting language

echo -a Hello, world!

MUMPS

Main article: MUMPS

w "Hello, world!"

O

Oberon

Main article: Oberon programming language

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

Obix

Main article: Obix programming language

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

Objective-C

Main article: Objective-C

#import <stdio.h>
 
int main(void)
{
    NSLog(@"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

Main article: OCaml

 print_endline "Hello, world!"

Opa

Main article: Opa (programming language)

A "hello world" web server:

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

Oriel

Main article: Oriel (scripting language)

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

Oz

Main article: Oz (programming_language)

{Show 'Hello World'}

P

Pascal

Main article: Pascal (programming language)

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

Pawn

Main article: Pawn (scripting language)

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

Perl 5

Main article: Perl

print "Hello, world!";

Or

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

PHP

Main article: PHP

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

or

<?php print ('Hello, world!'); ?>

or

<?= 'Hello, world!'; ?>

PL/SQL

Main article: PL/SQL

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

PostScript

Main article: PostScript

%!PS
/Courier 72 selectfont
20 20 moveto
(Hello World!) show
showpage

PowerShell

Main article: Windows PowerShell

"Hello, world!"

Processing

Main article: Processing (programming language)

void setup(){
  println("Hello, world!");
}

Prolog

Main article: Prolog

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

Python

Main article: Python (programming language)

Python 2:

print "Hello, world!"

Python 3:

print("Hello, world!")

R

R

Main article: R (programming language)

cat('Hello, world!\n')

Racket

Main article: Racket (programming language)

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

In Scribble, Racket's documentation language:

Hello, world!

Red

Main article: Red (programming language)

Red [
    Title: "Simple hello world script"
]

print "Hello World!"

REXX

Main article: REXX

say Hello, world!

RPL

Main article: RPL (programming language)

<< "Hello, world!" MSGBOX >>

RTL/2

Main article: 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

Main article: Ruby (programming language)

puts "Hello, world!"

Rust

Main article: Rust (programming language)

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

S

Scala

Main article: Scala (programming language)

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

Scheme

Main article: Scheme (programming language)

(display "Hello, world!")

Scratch

Main article: Scratch (programming language)

Hello, World! in Scratch

Sed

Main article: Sed

# convert input text stream to "Hello, world!"
s/.*/Hello, world!/
q

Shell

Main article: Bourne shell

echo Hello, world!

SimpleC

Main article: SimpleC

OUT<"Hello, world!"

Simula

Main article: Simula

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

Small Basic

Main article: Small Basic

TextWindow.WriteLine("Hello, World!")

Smalltalk

Main article: Smalltalk

Transcript show: 'Hello, world!'.

SmileBASIC

Main article: SmileBASIC

?"Hello, world!

or

PRINT "Hello, world!"

SNOBOL

Main article: SNOBOL

  OUTPUT = 'Hello, world!'
END

Speakeasy

Main article: Speakeasy (computational environment)

As an interactive statement :

"Hello, world!"

As a program :

program hello
   "Hello, world!"
end

SQL

Main article: 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!' -- Works for SQL Server, Microsoft Access, PostgreSQL and MySQL.

Stata

Main article: Stata

display "Hello, world!"

Supernova

Main article: Supernova (programming language)

I want window and the window title is hello world.

T

Tcl

Main article: Tcl

puts "Hello, world!"

Test-Driven Development with Java

Best-practice coding now involves writing the automated test before the code. The test is coded, the test may be demonstrated to fail, code is then added and corrected until the test passes.

import static org.junit.Assert.assertEquals;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import org.junit.Test;
 
public class HelloWorldTest {
	@Test
	public void sayHelloWorld() {
		ByteArrayOutputStream outContent = captureSystemOut();
 
		HelloWorld.say();
 
		assertEquals("Hello, World!", outContent.toString());
	}
 
	ByteArrayOutputStream captureSystemOut() {
		ByteArrayOutputStream outContent = new ByteArrayOutputStream();
		System.setOut(new PrintStream(outContent));
		return outContent;
	}
}

Then the simplest program to make the test pass is written.

public class HelloWorld {
	public static void say() {
		System.out.print("Hello, World!");
	}
}

TI-BASIC

Main article: TI-BASIC

PROGRAM:HELLOWLD
:ClrHome
:Disp "HELLO, WORLD!"

or

PROGRAM:HELLOWLD
:ClrDraw
:Output(1,1,"HELLO, WORLD!")
:DispGraph

For m68k calculators:

hellowld()
:Prgm
:  ClrIO
:  Disp "HELLO, WORLD!"
:EndPrgm

For Ti Nspire/CAS:

text"HELLO, WORLD!"

For Ti Nspire CX:

text "HELLO, WORLD!"

or

Disp "HELLO, WORLD"

Turing

Main article: Turing (programming language)

put "Hello World!"

U

UnrealScript

Main article: UnrealScript

Log("Hello, world!");

V

Vala

Main article: Vala (programming language)

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

VBScript

MsgBox "Hello World"

Verilog

Main article: Verilog

module hello();
 
initial begin
 
	$display("Hello, world!");
        $finish;
end
 
endmodule

VHDL

Main article: VHDL

entity hello_world is
end;
 
architecture hello_world of hello_world is
begin
  stimulus : PROCESS
  begin
    assert false report "Hello, world!"
    severity note;
    wait;
  end PROCESS stimulus;
end hello_world;

Visual Basic

Main article: Visual Basic

 MsgBox "Hello, world!"

Visual Basic .NET

Main article: 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

Main article: Whitespace (programming language)

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

X

XSLT

Main article : XSLT

<?xml version='1.0'  encoding="ISO-8859-1"?>
<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0' >
  <xsl:output method="text"/>
  <xsl:template match="/">
    <xsl:text>Hello World
</xsl:text>
  </xsl:template>
</xsl:stylesheet>

Z

Zimbu

Main article: Zimbu

FUNC Main() int
  IO.print("Hello, World!")
  RETURN 0
}

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.
• List of Hello World Programs in 300 Programming Languages - C and C++ Programming Resources, hello world examples for 300 programming languages.