List of Hello World Programs in 300 Programming Languages

Hello, world! Programs are usually written to make the text “Hello, world!” appear on a computer screen. This is also a basic sanity check for an installation of a new programming language. The first Hello World program appeared in chapter 1.1 of the first edition of Kernighan & Ritchie’s original book about C, ‘The C Programming Language’, in 1978. This is considered to be the first ever “Hello World!” program.

This is a complete list of “Hello World!” programs written in more than 300 existing programming languages including Assembly language, Low-level, High-level, Object Oriented, Document formats, Page description languages and Scripting languages.

List of the following 16 programming languages are added on December 19, 2017.

swift, go, chill, nomad (4GL), Hack, Ring, Crystal, Julia, Elixir, Red, Kotlin, Elm, Dart, Ceylon, Rust, Chapel

4DOS Batch

1 @echo Hello, world

4GL

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

4Test

1 2 3 // Hello World in 4Test testcase printHelloWorld ( ) print ( "Hello World!" )

1 [ ] < - ’ Hello World ! ’

Abap – SAP AG

1 WRITE 'Hello, World!' .

ABC

1 WRITE "Hello, world!"

ActionScript

1 trace ( "Hello, World!" ) ;

1 2 this . createTextField ( "hello_txt" , 0 , 10 , 10 , 100 , 20 ) ; this . hello_txt . text = "Hello, World!" ;

ActionScript 3

1 2 3 4 5 6 7 8 package { import flash.display . Sprite ; public class HelloWorld extends Sprite { public function HelloWorld ( ) { trace ( "Hello, world!" ) ; } } }

Ada

1 2 3 4 5 with TEXT_IO ; procedure HELLO is begin TEXT_IO . PUT_LINE ( "Hello, World!" ) ; end HELLO ;

Adobe Flex MXML

1 2 3 4 <?xml version = "1.0" encoding = "utf-8" ? > <mx:Application xmlns : mx = "http://www.adobe.com/2006/mxml" > <mx:Label text = "Hello, world!" /> </mx:Application>

Algol 60

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

Algol 68

1 2 3 BEGIN print ( ( "Hello, World!" , newline ) ) END

1 ( print ( "Hello, World!" ) )

Alma-0

1 Hello , World !

AmigaE

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

AMX NetLinx

1 2 3 program_name = 'Hello' define_start send _ string 0 , 'Hello World!'

Apl

1 'Hello, World!'

AppleScript

1 return "Hello, World!"

1 -- "Hello World!"

1 display dialog "Hello World!" buttons { "OK" } default button 1

Ascii

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

Asp

1 2 3 < % Response . Write ( "Hello, World!" ) % >

1 < %= "Hello, World!" % >

Asp.Net

1 Response . Write ( "Hello, World!" )

AspectJ

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

Assembly Languages

Aassembler – 6502

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

Assembler – Intel x86, Dos, Tasm

1 2 3 MODEL SMALL IDEAL STACK 100H

1 2 DATASEG MSG DB 'Hello, World!' , 13 , '$'

1 2 3 4 5 6 7 8 9 10 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

Assembler – Intel x86, Linux

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 SECTION . data msg : db "Hello, World!

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

1 2 3 4 5 6 7 8 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

Assembler – General-purpose fictional computer: MIX, MIXAL

1 2 3 4 5 6 7 8 9 10 General - purpose fictional computer : MIX , MIXAL TERM EQU 19 console device no . ( 19 = typewriter ) ORIG 1000 start address START OUT MSG ( TERM ) output data at address MSG HLT halt execution MSG ALF "HELLO" ALF " WORL" ALF "D " END START end of program

RISC processor: MIPS architecture

1 2 3 4 5 6 7 8 9 10 . data msg : . asciiz "Hello, world!" . align 2 . text . globl main main : la $ a0 , msg li $ v0 , 4 syscall jr $ ra

Arm, Risc OS:

1 2 3 4 5 6 7 8 . program ADR R0 , message SWI "OS_Write0" SWI "OS_Exit" . message DCS "Hello, World!" DCB 0 ALIGN

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

AutoHotkey

1 MsgBox , "Hello, World!"

Autoit

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

Avenue – Scripting language for ArcView GIS

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

AviSynth

1 2 BlankClip ( ) Subtitle ( "Hello, world!" )

Awk

1 2 3 # Hello BEGIN { print "Hello, World!" }

B

1 2 3 4 5 6 7 8 9 /* Hello */ main ( ) { extern a , b , c ; putchar ( a ) ; putchar ( b ) ; putchar ( c ) ; putchar ( '!*n' ) ; } a 'hell' ; b 'o, w' ; c 'orld' ;

Baan Tools

1 2 3 4 function main ( ) { message ( "Hello, world!" ) }

Ball

1 write Hello , * s world * n

Bash or sh

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

1 printf 'Hello, world!

'

Basic

1 2 10 PRINT "Hello, World!" 20 END

1 2 PRINT "Hello, World!" ? "Hello, World!"

1 2 PRINT "Hello, World!" END

BlitzBasic

1 2 Print "Hello, world!" WaitKey

DarkBasic

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

Liberty BASIC

1 print "Hello, world"

1 2 3 4 5 6 nomainwin open "Hello, world!" for graphics as #main print #main, "place 50 50" print #main, "\Hello, world!" print #main, "flush" wait

PBasic

1 DEBUG "Hello, World!" , CR

1 2 3 4 5 6 7 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

Basic – StarOffice/OpenOffice

1 2 3 sub main print "Hello, World!" end sub

TI-BASIC

1 2 3 4 : hellowld ( ) : Prgm : Disp "Hello, world!" : EndPrgm

Visual Basic

1 2 3 Sub Main ( ) Print "Hello, World!" End Sub

Visual Basic .Net

1 2 3 4 5 Module HelloWorldApp Sub Main ( ) System . Console . WriteLine ( "Hello, World!" ) End Sub End Module

1 2 3 4 5 Class HelloWorldApp Shared Sub Main ( ) System . Console . WriteLine ( "Hello, World!" ) End Sub End Class

bc

1 "Hello, world!"

1 print "Hello, world!

"

Bcpl

1 2 3 4 5 6 // Hello GET "LIBHDR" LET START ( ) BE $ ( WRITES ( "Hello, World!*N" ) $ )

Beta

1 2 3 4 5 { * * * Hello * * * } ( # do 'Hello World!' - & gt ; putLine #)

BITGGAL AgileDog

1 2 3 T 1 "Hellow, World" 0

BITGGAL Jihwaja

1 J ( 1 TM 5 ZV 3 "Hellow, world" )

Bliss

1 2 3 4 5 6 7 8 9 10 11 12 13 14 % 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

1 print "Hello, World!"

Burning Sand 2

1 WRITE ELEMENT : Earth 210 230 40 CENTER TEXT "Hello World!"

C

1 2 3 4 5 #include <stdio.h> int main ( void ) { printf ( "Hello, world!

" ) ; return 0 ; }

C#

1 2 3 4 5 6 using System ; class HelloWorld { static void Main ( ) { System . Console . WriteLine ( "Hello, World!" ) ; } }

C++ (ISO)

1 2 3 4 5 #include <iostream> int main ( ) { std :: cout << "Hello, World!

" ; }

C++ / Cli

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

C++ Managed (.Net)

1 2 3 4 5 6 #using <mscorlib.dll> using namespace System ; int wmain ( ) { Console :: WriteLine ( "Hello, World!" ) ; }

C#

1 2 3 4 5 class HelloWorldApp { static void Main ( ) { System . Console . WriteLine ( "Hello, world!" ) ; } }

Caché Server Pages (CSP)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 Class Test . Hello Extends % CSP . Page [ ProcedureBlock ] { ClassMethod OnPage ( ) As % Status { & html << html > < head > < / head > < body >> Write "Hello, world!" , ! & html << / body > < / html >> Quit $ $ $ OK } }

Caml light

1 2 3 4 5 ( * Hello World * ) let hello = print _ string "Hello World!" ; ; ;

CCL

1 call echo ( "Hello, world!" )

Ceylon

1 2 3 shared void run ( ) { print ( "Hello, World!" ) ; }

Ch

1 printf ( "Hello, world!

" ) ;

Chapel

1 writeln ( "Hello, world!" ) ;

CHILL

1 2 3 4 5 6 Hello : MODULE WRITETEXT ( STDOUT , "Hello World!%/" ) ; END Hello ;

Chuck

1 <<< "Hello World" >>>

Chrome

1 2 3 4 5 6 7 8 9 10 11 12 13 14 namespace HelloWorld ; interface type HelloClass = class public class method Main ; end ; implementation class method HelloClass . Main ; begin System . Console . WriteLine ( 'Hello, world!' ) ; end ; end .

Cil

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

Clarion

1 2 3 4 5 6 PROGRAM MAP END CODE MESSAGE ( 'Hello, world!!' , 'Clarion' ) RETURN

Clean

1 2 3 module hello Start = "Hello, World!"

Clist

1 2 PROC 0 WRITE Hello , World !

Clipper

1 ? "Hello, World!"

Clu

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

Cobol

1 2 3 4 5 6 7 8 9 10 IDENTIFICATION DIVISION . PROGRAM - ID . HELLO - WORLD . ENVIRONMENT DIVISION . DATA DIVISION . PROCEDURE DIVISION . DISPLAY "Hello, World!" . STOP RUN .

Cocoa or GnuStep (Objective C)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #import <Cocoa/Cocoa.h> @interface hello : NSObject { } @end @implementation hello - ( void ) awakeFromNib { NSRunAlertPanel ( @"Message from your Computer" , @"Hello, World!" , @"Hi!" , nil , nil ) ; } @end

ColdFusion

1 <cfoutput> Hello, World! </cfoutput>

Comal

1 PRINT "Hello, World!"

ConTeXt

1 2 3 \ starttext Hello , world ! \ stoptext

Crystal

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 puts "Hello World!" #Object Oriented Style class Greeter def initialize ( @ name : String ) end def salute puts "Hello #{@name}!" end end g = Greeter . new ( "world" ) g . salute

Curl

1 2 3 4 { curl 3.0 , 4.0 applet } { curl - file - attributes character - encoding = "utf-8" } Hello , World !

D

1 2 3 4 5 import std . stdio ; void main ( ) { writef ( "Hello, World!" ) ; }

D++

1 2 3 4 function main ( ) { screenput "Hello, World!" ; }

Dart

1 2 3 main ( ) { print ( 'Hello World!' ) ; }

Dataflex

1 2 3 4 5 / tela Hello world / * clearscreen page tela

dBase

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

DC an arbitrary precision calculator

1 [ Hello , world ! ] p

Dcl batch

1 $ write sys $ output "Hello, World!"

DIV

1 2 3 4 5 6 7 PROGRAM hello ; BEGIN write ( 0 , 0 , 0 , 0 , "Hello, world!" ) ; LOOP FRAME ; END END

Delphi, Kylix

1 2 3 4 5 6 7 8 program Hello_World ; uses Windows ; begin ShowMessage ( "Hello, World!" ) ; end .

Doll

1 2 3 4 5 this :: operator ( ) { import system . cstdio ; puts ( "Hello, World!" ) ; }

Dream Maker

1 2 3 4 mob Login ( ) . . ( ) world << "Hello, world!"

Dylan

1 2 module : hello format - out ( "Hello, world!

" ) ;

EAS 0.0.1.*

1 2 3 set disp to "Hello, world!" set dispto to item unit 5 //5 = default screen release disp into dispto .

1 2 import system ea . helloworld wait

Ed and Ex (Ed extended)

1 2 3 4 a hello World ! . p

Eiffel

1 2 3 4 5 6 7 8 class HELLO_WORLD create make feature make is do io . put_string ( "Hello, world!%N" ) end -- make end -- class HELLO_WORLD

Elan

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

Elixir

1 iex > IO . puts "Hello World!"

Elm

1 2 main = text "Hello"

Erlang

1 2 3 4 - module ( hello ) . - export ( [ hello_world / 0 ] ) . hello_world ( ) - & gt ; io : fwrite ( "Hello, World!

" ) .

Euphoria

1 puts ( 1 , "Hello, World!" )

1 print _ endline "Hello, World!"

1 printfn " Hello , world !

Factor

1 "Hello, World!" print

Ferite

1 2 uses "console" ; Console . println ( "Hello, world!" ) ;

filePro

1 2 @ once : mesgbox "Hello, world!" ; exit

Fjölnir

1 2 3 4 5 6 7 8 9 10 11 "halló" < main { main -> stef ( ; ) stofn skrifastreng ( ; "Halló, veröld!" ) , stofnlok } * "GRUNNUR" ;

Focal

1 type "Hello, World!" , !

1 t "Hello, world!" , !

Focus

1 - TYPE Hello world

Forte TOOL

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 begin TOOL HelloWorld ; includes Framework ; HAS PROPERTY IsLibrary = FALSE ; forward Hello ; -- START CLASS DEFINITIONS class Hello inherits from Framework . Object has public method Init ; has property shared = ( allow = off , override = on ) ; transactional = ( allow = off , override = on ) ; monitored = ( allow = off , override = on ) ; distributed = ( allow = off , override = on ) ; end class ; -- END CLASS DEFINITIONS -- START METHOD DEFINITIONS -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- method Hello . Init begin super . Init ( ) ; task . Part . LogMgr . PutLine ( 'Hello, world!' ) ; end method ; -- END METHOD DEFINITIONS HAS PROPERTY CompatibilityLevel = 0 ; ProjectType = APPLICATION ; Restricted = FALSE ; MultiThreaded = TRUE ; Internal = FALSE ; LibraryName = 'hellowor' ; StartingMethod = ( class = Hello , method = Init ) ; end HelloWorld ;

Forth

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

1 CR . " Hello, world!" CR

Fortran

1 2 3 PROGRAM HELLO PRINT * , 'Hello, World!' END

FreeBasic

1 2 3 PRINT "Hello World" SLEEP END

Fril

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

Frink

1 println [ "Hello, World!" ]

Gambas

1 2 3 PUBLIC SUB Main ( ) Print "Hello, World!" END

1 2 3 PUBLIC SUB Main ( ) Message . Info ( "Hello, World!" ) END

Game Maker

1 draw_text ( x , y , "Hello, world!" )

1 show_message ( "Hello, world!" )

GEMBase 4GL

1 2 3 4 5 procedure_form hello begin_block world print "Hello, world!" end_block end_form

Go Language

1 2 3 4 5 6 7 package main import "fmt" func main ( ) { fmt . Println ( "Hello World" ) }

GraalScript 1

1 2 3 if ( created ) { echo Hello , world ! ; }

GraalScript 2

1 2 3 function onCreated ( ) { echo ( "Hello, world!" ) ; }

Groovy

1 println "Hello, world!"

Gtk+ in C++

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 #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#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 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 ( ) ; } }

Haskell

1 main = putStrLn "Hello, world!"

1 2 3 module Main ( main ) where main = putStrLn "Hello, World!"

Hack

1 2 <? hh echo 'Hello World' ;

haXe

1 2 3 4 5 6 7 class HelloWorldApp { static function main ( ) { trace ( "Hello, world!" ) ; } }

Heron

1 2 3 4 5 6 7 program HelloWorld ; functions { _main ( ) { print_string ( "Hello, world!" ) ; } } end

HLA (High Level Assembly)

1 2 3 4 5 6 7 program helloWorld ; #include("stdlib.hhf") #begin helloWorld; stdout . put ( "Hello World" nl ) ; end helloWorld ;

HP 33s

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 LBL H SF 10 EQN RCL H RCL E RCL L RCL L RCL O R / S RCL W RCL O RCL R RCL L RDL D ENTER R / S

HP-41, HP-42S

1 2 3 01 LBLTHELLO 02 THELLO , WORLD 03 PROMPT

Html

1 2 3 4 5 <html> <body> Hello, World! </body> </html>

HTML 4.01 Strict

1 2 3 4 5 6 7 8 9 10 <!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

1 put "Hello, World!"

1 Answer "Hello, World!"

Icon

1 2 3 4 # In Icon rocedure main ( ) write ( "Hello world" ) end

IDL

1 print , "Hello World!"

Inform 5/6

1 2 3 [ Main ; "Hello, World!" ; ] ;

Inform 7

1 Hello World is a room . The printed name is "Hello, world!"

Intercal

1 2 IN INTERCAL HELLO WORLD

Io

1 "Hello, world!" println

1 writeln ( "Hello, world!" )

Iptscrae

1 2 3 ON ENTER { "Hello, " "World!" & amp ; SAY }

J

1 'Hello world'

1 'Hello, world!' NB . echoes the string in interactive mode , doesn ' t work in script

1 'Hello World!' 1 ! : 2 ( 2 ) NB . prints it to ( 2 ) - screen , ( 4 ) - stdout

Jal

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 include 16f877_20 include hd447804 hd44780_clear hd44780 = "H" hd44780 = "e" hd44780 = "l" hd44780 = "l" hd44780 = "o" hd44780 = " " hd44780 = "W" hd44780 = "o" hd44780 = "r" hd44780 = "l" hd44780 = "d" hd44780 = "!"

Java

1 2 3 4 5 6 7 public class HelloWorld { public static void main ( String [ ] args ) { System . out . println ( "Hello, world!" ) ; } }

Java byte-code

1 2 3 4 5 6 7 8 9 10 11 12 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 }

JavaFX

1 2 3 4 5 6 7 8 Frame { title : "Hello World JavaFX" width : 200 content : Label { text : "Hello World" } visible : true }

1 2 3 4 5 6 7 var win = new Frame ( ) ; win . title = "Hello World JavaFX" ; win . width = 200 ; var label = new Label ( ) ; label . text = "Hello World" ; win . content = label ; win . visible = true ;

1 2 import java . lang . System ; System . out . println ( "Hello World" ) ;

1 println ( "Hello World" ) ;

Java Swing

1 2 3 4 5 6 7 8 9 import javax . swing . JOptionPane ; public class Hello { public static void main ( String [ ] args ) { JOptionPane . showMessageDialog ( null , "Hello, World!" ) ; } }

Java SWT

1 2 3 4 5 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 ;

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 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

1 2 3 4 5 6 7 8 9 10 11 12 13 <HTML> <HEAD> <TITLE> Hello world </TITLE> </HEAD> <BODY> HelloWorld Program says: <APPLET CODE = "HelloWorld.class" WIDTH = 600 HEIGHT = 100 > </APPLET> </BODY> </HTML>

1 2 3 4 5 6 7 8 import java . applet . * ; import java . awt . * ; public class HelloWorld extends Applet { public void paint ( Graphics g ) { g . drawString ( "Hello, World!" , 100 , 50 ) ; } }

JavaScript

1 document . writeln ( 'Hello, World!' ) ;

1 alert ( 'Hello, world!' ) ;

1 print ( 'Hello, world!' ) ;

1 WScript . Echo ( 'Hello, world!' ) ;

1 <a href = "#" onclick = "helloWorld(); return false;" > Hello World Example </a>

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

JSP

1 < % out . println ( "Hello, world!" ) ; % >

1 Hello , world !

Joy

1 "Hello, world!

" putchars .

Julia

1 julia > println ( "Hello world!" )

K

1 ` 0 : "Hello world

"

Kogut

1 WriteLine "Hello, World!"

Kotlin

1 2 3 4 fun main ( args : Array <String> ) { val scope = "world" println ( "Hello, $scope!" ) }

KPL (Kids Programming Language)

1 2 3 4 5 6 Program HelloWorld Method Main ( ) ShowConsole ( ) ConsoleWriteLine ( "Hello, world!" ) End Method End Program

Lasso

1 Output : 'Hello, world!' ;

1 Output ( 'Hello, world!' ) ;

1 'Hello, world!' ;

LaTeX

1 2 3 4 \ documentclass { article } \ begin { document } Hello , World ! \ end { document }

Lexico Mobile (in spanish)

1 tarea muestre "Hola mundo !"

1 2 3 4 clase Saludo derivada_de Form publicos mensajes Saludo copie "Hola mundo !" en saludo . Text

Limbo

1 2 3 4 5 6 7 8 9 10 implement Command ; include "sys.m" sys : Sys ; include "draw.m" ; include "sh.m" ; init ( nil : ref Draw - & gt ; Context , nil : list of string ) { sys = load Sys Sys - & gt ; PATH ; sys - & gt ; print ( "Hello, world!!

" ) ; }

Linden Scripting Language

1 2 3 4 5 6 7 default { state _ entry ( ) { llSetText ( "Hello, World!" , < 0 , 0 , 0 > , 1.0 ) ; } }

Lingo (Macromedia Director scripting language)

1 2 3 on exitFrame me put "Hello, world!" end

Linotte

1 2 3 4 Livre : HelloWorld Paragraphe : Affichage Actions : "Hello, World !" !

Lisaac

1 2 3 4 5 6 7 8 9 10 section HEADER + name : = HELLO_WORLD ; - category : = MACRO ; section INHERIT - parent_object : OBJECT : = OBJECT ; section PUBLIC - make < - ( "Hello World !

" . print ; ) ;

Lisp

Common Lisp

1 ( format t "Hello World!~%" )

1 ( write -line "Hello World!" )

1 "Hello World!"

Scheme

1 ( display "Hello, World!" )

Emacs Lisp

1 ( print "Hello, World!" )

AutoLisp

1 ( print "Hello, World!" )

XLisp

1 ( print "Hello, World!" )

Arc

1 ( prn "Hello, world!" )

Logo

1 print [ Hello World ! ]

1 pr [ Hello World ! ]

1 messagebox [ Hi ] [ Hello , world !

LPC

1 2 3 4 void create ( ) { write ( "Hello, world!

" ) ; }

Lua

1 print "Hello, World!"

LuaPSP

1 2 screen : print ( 1 , 1 , "Hello, world!" ) screen : flip ( )

M (MUMPS)

1 W "Hello, world!"

M4

1 Hello , World !

Macsyma, Maxima

1 print ( "Hello, World!" ) $

Maple

1 & gt ; & gt ; print ( "Hello, World!" ) ;

Mathematica

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

1 "Hello, world!"

Matlab

1 disp ( 'Hello world' )

1 fprintf ( 'Hello, world!' )

Maude

1 2 3 4 5 6 fmod HELLOWORLD is protecting STRING . op helloworld : - & gt ; String . eq helloworld = "Hello, World." . endfm red helloworld .

Max

1 2 3 4 5 6 7 8 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;

Maya Embedded Language

1 print ( "Hello, world!

" ) ;

Microsoft Foundation Classes (in C++)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 #include <afx.h> #include <afxwin.h> class CHelloWin : public CWnd { protected : DECLARE_MESSAGE_MAP ( ) afx_msg void OnPaint ( void ) { CPaintDC dc ( this ) ; dc . TextOut ( 15 , 3 , TEXT ( "Hello, world!" ) , 13 ) ; } } ; BEGIN_MESSAGE_MAP ( CHelloWin , CWnd ) ON_WM_PAINT ( ) END_MESSAGE_MAP ( ) class CHelloApp : public CWinApp { virtual BOOL InitInstance ( ) ; } ; CHelloApp theApp ; LPCTSTR wndClass ; BOOL CHelloApp :: InitInstance ( ) { CWinApp :: InitInstance ( ) ; CHelloWin * hello = new CHelloWin ( ) ; m_pMainWnd = hello ; wndClass = AfxRegisterWndClass ( CS_VREDRAW | CS_HREDRAW , 0 , ( HBRUSH ) :: GetStockObject ( WHITE_BRUSH ) , 0 ) ; hello -> CreateEx ( 0 , wndClass , TEXT ( "Hello MFC" ) , WS_OVERLAPPEDWINDOW , CW_USEDEFAULT , CW_USEDEFAULT , 120 , 50 , NULL , NULL ) ; hello -> ShowWindow ( SW_SHOW ) ; hello -> UpdateWindow ( ) ; return TRUE ; }

mIrc Script

1 echo Hello World

Model 204

1 2 3 BEGIN PRINT 'Hello, World!' END

Modula-2

1 2 3 4 5 6 7 8 MODULE Hello ; FROM InOut IMPORT WriteLn , WriteString ; BEGIN WriteString ( "Hello, World!" ) ; WriteLn END Hello .

Moo

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

Mouse

1 "Hello, World!" $

Ms-Dos batch

1 @ echo Hello , World !

Muf

1 2 3 : main me @ "Hello, World!" notify ;

Natural

1 2 WRITE "Hello, World!" END

Nemerle

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

1 2 3 4 5 6 7 8 using System . Console ; module HelloWorld { Main ( ) : void { WriteLine ( "Hello, world!" ) ; } }

NewtonScript

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 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

1 2 3 4 void main ( String [ ] args ) { println ( "hello world" ) ; }

NOMAD (4GL)

1 print "Hello World." ;

NSIS

1 2 3 4 5 6 7 8 9 10 11 OutFile "HelloWorld.exe" Name "Hello, world!" Caption "Hello, world!" Section Hello , world ! SectionEnd Function . onInit MessageBox MB _ OK "Hello, world!" Quit FunctionEnd

Oberon

1 2 3 4 5 6 MODULE Hello ; IMPORT Out ; BEGIN Out . String ( "Hello World!" ) ; Out . Ln END Hello .

Object-Oriented C Version

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #import <stdio.h> #import <objc/Object.h> @ interface Hello : Object { } - hello ; @ end @ implementation Hello - hello { printf ( "Hello, world!

" ) ; } @ end int main ( void ) { id obj ; obj = [ Hello new ] ; [ obj hello ] ; [ obj free ] ; return 0 ; }

OPENSTEP/Cocoa Version

1 2 3 4 5 #import <Foundation/Foundation.h> int main ( int argc , const char * argv [ ] ) { NSLog ( @ "Hello, world!" ) ; return 0 ; }

OCaml

1 print _ endline "Hello World!"

Occam

1 2 3 4 5 #USE "course.lib" PROC hello . world ( CHAN OF BYTE screen ! ) out . string ( "Hello World!*n" , 0 , screen ! ) :

Octave

1 printf ( "Hello World

" ) ;

Opl

1 2 3 PROC hello : PRINT "Hello, world" ENDP

Ops5

1 2 3 4 5 6 7 8 9 10 11 12 ( object - class request ^ action ) ( startup ( strategy MEA ) ( make request ^ action hello ) ) ( rule hello ( request ^ action hello ) ( write | Hello World ! | ( crlf ) ) )

Ops83

1 2 3 4 5 6 module hello ( main ) { procedure main ( ) { write ( ) | Hello , World ! | , '

' ; } ; } ;

Oz

1 { Browse 'Hello World!' }

Parrot assembly language

1 2 print "Hello, World!

" end

Parrot intermediate representation

1 2 3 . sub hello : main print "Hello, world!!

" . end

Pascal

1 2 3 4 5 program hello ; begin writeln ( 'Hello, World!' ) ; end .

PAWN

1 2 3 4 main ( ) { print ( "Hello World" ) ; }

Pdf

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 % 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

1 2 # Hello print "Hello, World!

" ;

Perl 6

1 say "Hello world" ;

PHP

1 2 3 <?php echo 'Hello, World!' ; ?>

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

1 <?= 'Hello, World!' ?>

Pike

1 2 3 4 int main ( ) { write ( "Hello, World!

" ) ; return 0 ; }

Pilot

1 T : Hello , World !

Pl/Sql

1 2 3 4 5 6 7 -- 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

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

Pop-11

1 'Hello world' =& gt ;

PostScript

1 ( Hello , world ! \ n ) print

Pov-Ray

1 2 3 4 5 6 7 8 9 10 #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

1 println ( "Hello, world!" ) ;

Profan

1 2 3 4 ' Hello in Profan cls print "Hello World!" waitkey

Progress

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

Prolog

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

Pure Data

1 2 3 4 5 6 #N canvas 0 0 300 300 10; #X obj 100 100 loadbang; #X msg 100 150 Hello, world!; #X obj 100 200 print; #X connect 0 0 1 0; #X connect 1 0 2 0;

Protocol Buffers

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

PureBasic

1 2 3 4 5 ; In PureBasic console OpenConsole ( ) ConsoleTitle ( "Hello World!" ) PrintN ( "Hello World!" ) CloseConsole ( )

Python

1 print "Hello, World!"

Qt toolkit (C++)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 #include <qapplication.h> #include <qpushbutton.h> #include <qwidget.h> #include <iostream> class HelloWorld : public QWidget { Q_OBJECT public : HelloWorld ( ) ; virtual ~ HelloWorld ( ) ; public slots : void handleButtonClicked ( ) ; QPushButton * mPushButton ; } ; HelloWorld :: HelloWorld ( ) : QWidget ( ) , mPushButton ( new QPushButton ( "Hello, World!" , this ) ) { connect ( mPushButton , SIGNAL ( clicked ( ) ) , this , SLOT ( handleButtonClicked ( ) ) ) ; } HelloWorld :: ~ HelloWorld ( ) { } void HelloWorld :: handleButtonClicked ( ) { std :: cout << "Hello, World!" << std :: endl ; } int main ( int argc , char * argv [ ] ) { QApplication app ( argc , argv ) ; HelloWorld helloWorld ; app . setMainWidget ( &helloWorld ) ; helloWorld . show ( ) ; return app . exec ( ) ; }

QuakeC

1 bprint ( "Hello World

" ) ;

QuickBasic

1 2 3 REM Hello World in QuickBASIC PRINT "Hello World!" END

R

1 cat ( "Hello world

" )

Ratfor

1 2 print * , 'hello, world' end

RealBasic

1 2 ' Hello msgBox "Hello World!"

Rebol

1 print "Hello, World!"

Red

1 2 3 4 Red [ Title : "Simple hello world script" ] print "Hello World!"

Refal

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

Rexx, ARexx, NetRexx, and Object REXX

1 say "Hello, World!"

Ring

1 2 3 4 5 6 See "Hello, World!" Put "Hello, World!" Load "stdlib.ring" Print ( "Hello, World!" )

Robotic (MegaZeux)

1 2 * "Hello, world!" end

Rpg

Free-Form Syntax

1 2 3 4 / FREE DSPLY 'Hello, World!' ; * InLR = * On ; / END - FREE

Traditional Syntax

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

Rpg Code

Message Window

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

On Screen Text

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

RPL (HP calculators)

1 2 3 4 5 6 << CLLCD "Hello, World!" 1 DISP 0 WAIT DROP >>

Rsl

1 [ Hello World ! ] ;

RT Assembler

1 2 3 _name Hello ~ World ! pause Hello ~ World ! exit _end

Rtf

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

RTML

1 2 < strong > Hello < / strong > ( ) TEXT "Hello, world!"

Ruby

1 puts "Hello, World!"

Rust

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

S

1 cat ( "Hello world

" )

S-Lang

1 message ( "Hello, world!" ) ;

Sas

1 2 3 data _null_ ; put 'Hello, World!' ; run ;

Sather

1 2 3 4 5 class HELLO_WORLD is main is #OUT+"Hello world

"; end ; end ;

Scala

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

SCAR

1 2 3 4 program HelloWorld ; begin WriteLn ( 'Hello world!' ) ; end .

Scheme

1 2 ( display "Hello world!" ) ( newline )

Scriptol

1 print "Hello World!"

sed

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

Seed7

1 2 3 4 5 6 $ include "seed7_05.s7i" ; const proc : main is func begin writeln ( "Hello, World!" ) ; end func ;

Self

1 'Hello, World!' print .

Setl

1 2 3 4 5 -- Hello in Setl2 procedure Hello ( ) ; print "Hello World!" ; end Hello ;

Simula

1 2 3 4 BEGIN OutText ( "Hello, World!" ) ; OutImage ; END

Smalltalk

1 Transcript show : 'Hello, World!' ; cr

Smil

1 2 3 4 5 6 7 8 9 10 11 12 13 14 <!-- 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

1 print "Hello, World!

" ;

Snobol

1 2 OUTPUT = "Hello, World!" END

ShadowScript

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 'set up initial variables struct.follow { cpu.fan.speed(500.rpm) cpu.max.process(100) } < logic.handle(0) int main() int var() array.max(100000000) > ' open and write the text in a free handle window open mainwin ( io < std > ) as free ( 1 ) { write . free ( 1 ) . ( "Hello" , & sym , " world" , & sym ) ( & sym < "," > & sym < "!" > apply . free ( 1 ) to text } 'reset the fan, cpu, and vars < logic(std) fan(std.auto) cpu.max(auto) unint main() unint var() un.array.max(std) > ' end end . end /

Span

1 2 3 4 5 class Hello { static public main : args { Console << "Hello, World!

" ; } }

Spark

1 2 3 4 5 6 7 8 9 10 11 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

1 2 OUTPUT = "Hello, World!" END

SSPL

1 2 3 1.0 print Hello , World ! end

SPSS Syntax

1 ECHO "Hello, world!" .

Sql

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

MySQL or PostgreSQL:

1 SELECT 'Hello, World!' ;

Starlet

1 RACINE : HELLO_WORLD .

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

STATA

Define program in script (.do-file) or at command line:

1 2 3 4 program hello /*Define Hello, world! program*/ di "Hello, world!" end hello /*run Hello, world! program*/

1 di "Hello, world!"

SuperCollider

1 "Hello World" . postln ;

Svg

1 2 3 4 5 6 7 8 9 <?xml version = "1.0" encoding = "utf-8" standalone = "no" ? > <svg width = "240" height = "100" viewBox = "0 0 240 100" zoomAndPan = "disable" xmlns = "http://www.w3.org/2000/svg" xmlns : xlink = "http://www.w3.org/1999/xlink" > <title> Hello World </title> <g> <text x = "10" y = "50" > Hello World </text> <animate attributeName = 'opacity' values = '0;1' dur = '4s' fill = 'freeze' begin = "0s" /> </g> </svg>

Swift

1 print ( "hello world" )

T programming language

1 2 3 4 5 % begin @ jump $ main % main . 0 @ echo % msg % main . 1 @ end % main . count 2 % msg Hello , world !

Tacl

1 2 ? TACL HELLO #OUTPUT Hello, World!

Tcl (Tool command language)

1 puts "Hello, World!"

Teco

1 2 ! Hello in TECO FTHello World $

Template Toolkit

1 [ % GET "Hola mundo!" ; % ]

TeX

1 2 Hello world \ bye

Ti-Basic

1 2 3 4 5 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

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

TOM (rewriting language)

1 2 3 4 5 6 7 8 9 public class HelloWorld { % include { string . tom } public final static void main ( String [ ] args ) { String who = "world" ; % match ( String who ) { "World" - & gt ; { System . out . println ( "Hello, " + who + "!" ) ; } _ - & gt ; { System . out . println ( "Don't panic" ) ; } } }

TSQL

1 2 3 Declare @ Output varchar ( 16 ) Set @ Output = 'Hello, world!' Select 'Output' = @ Output

1 2 Select 'Hello, world!' Print 'Hello, world!'

TTCN-3

1 2 3 4 5 module hello_world { control { log ( "Hello, world!" ) ; } }

Turing

1 put "Hello, World!"

Ubercode

1 2 3 4 5 6 Ubercode 1 class Hello public function main ( ) code call Msgbox ( "Hello" , "Hello, world!" ) end function end class

Uniface

1 message "Hello, world!"

Unix shell

1 echo 'Hello, World!'

1 2 3 cat & lt ; & lt ; 'DELIM' Hello , World ! DELIM

1 printf '%s' $ 'Hello, World!

'

UnrealScript

1 2 3 4 5 6 7 8 9 10 11 class HelloHUD extends HudBase ; simulated function DrawHudPassC ( Canvas C ) { C . SetPos ( 0.50 * C . ClipX , 0.50 * C . ClipY ) ; C . DrawText ( "Hello World!" ) ; } defaultproperties { }

XUL

1 2 3 4 5 <?xml version = "1.0" ? > <?xml-stylesheet href = "chrome://global/skin/" type = "text/css" ? > <window id = "yourwindow" xmlns = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" > <label value = "Hello, World!" /> </window>

Verilog

1 2 3 4 5 6 7 8 9 module main ; initial begin $ display ( "Hello, World" ) ; $ finish ; end endmodule

VHDL

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 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 Script

1 WScript . Echo "Hello, world!"

VBA

1 2 3 Sub Main ( ) MsgBox "Hello, world!" End Sub

Visual Basic .Net 2003

1 2 3 4 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

1 2 3 4 5 Public Class MyApplication Shared Sub Main ( ) MessageBox . Show ( "Hello World!" , "HELLO WORLD" ) End Sub End Class

Visual DialogScript

1 info Hello world !

Visual Prolog console program

1 2 3 4 5 #include @"pfc\console\console.ph" goal console :: init ( ) , stdio :: write ( "Hello, World!" ) .

Vms

1 $ WRITE SYS $ OUTPUT "Hello World!"

Vmrl

1 2 3 4 5 Shape { geometry Text { string "Hello World!" } }

Windows API (C Language)

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

Windows PowerShell

1 "Hello, world!"

1 Write - Host "Hello, world!"

1 echo "Hello, world!"

1 [ System . Console ] :: WriteLine ( "Hello, world!" )

Wscript

1 WScript . Echo ( "Hello World!" ) ;

1 2 3 4 5 6 7 8 9 10 11 class classHello { } static void main ( args Args ) { dialog dialog ; dialog = new dialog ( ) ; dialog . addText ( "Hello World!" ) ; dialog . run ( ) ; }

XAML/WPF

1 2 3 <Page xmlns = "http://schemas.microsoft.com/winfx/avalon/2005" > <TextBlock> Hello, World! </TextBlock> </Page>

XHTML 1.1

1 2 3 4 5 6 7 8 9 10 <?xml version = "1.0" encoding = "UTF-8" ? > <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> <html xmlns = "http://www.w3.org/1999/xhtml" xml : lang = "en" > <head> <title> Hello </title> </head> <body> <p> Hello, World! </p> </body> </html>

XL

1 2 use XL . UI . CONSOLE WriteLn "Hello, world!"

1 2 import IO = XL . UI . CONSOLE IO . WriteLn "Hello, world!"

Xml

1 2 3 4 5 6 <?xml version = "1.0" encoding = "ISO-8859-1" ? > <?xml-stylesheet type = "text/xsl" href = "HelloWorld.xsl" ? > <!-- Hello in XML --> <text> <string> Hello, World! </string> </text>

XQuery

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

XS programming language

1 <print> Hello, world! </print>

XSLT

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

Generate HTML

1 2 3 4 5 6 7 <xsl:template match = "/" > <html> <body> <h1> Hello, World! </h1> </body> </html> </xsl:template>

XUL

1 2 3 4 5 <?xml-stylesheet href = "chrome://global/skin" type = "text/css" ? > <window xmlns = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" align = "center" pack = "center" flex = "1" > <description> Hello, World! </description> </window>

Yorick

1 write , "Hello, world!" ;

Zebra Programming Language (ZPL)

1 2 3 4 5 6 ^XA ^LH30,6161 ^FO20,10 ^ADN,90,50 ^FDWikipedia^FS ^XZ

ZSH