Computer Programming/Hello world

Wikipedia has related information at Hello world program

The following is a list of Hello, world! programs.

Hello, world! programs make the text "Hello, world!" appear on a computer screen. It is usually the first program encountered when learning a programming language. Otherwise, it's a basic sanity check for an installation of a new programming language. If "Hello World" won't run, one must not try and develop complex programs before fixing the issues with the installation.

4DOS batch

It should be noted that the 4DOS/4NT batch language is a superset of the MS-DOS batch language.

 @echo Hello, world!

Ingres 4GL

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

ABAP/4 - SAP AG

REPORT ZHELLO.START-OF-SELECTION.  WRITE 'Hello, world!'.

ABAP OBJECTS (NETWEAVER 7) - SAP AG

The example below makes use of the singleton pattern and outputs the text in a message box instead of a classic list output.

REPORT ZHELLO.CLASS lcl_hello DEFINITION CREATE PRIVATE FINAL.  PUBLIC SECTION. CLASS-DATA self TYPE REF TO lcl_hello READ-ONLY. CLASS-METHODS class_constructor. METHODS say_hello.  PRIVATE SECTION. CONSTANTS con_hello_world TYPE c LENGTH 13 VALUE 'Hello, World!'.ENDCLASS.CLASS lcl_hello IMPLEMENTATION.  METHOD class_constructor. CREATE OBJECT lcl_hello=>self.  ENDMETHOD.  METHOD say_hello. MESSAGE con_hello_world TYPE 'I'.  ENDMETHOD.ENDCLASS.START-OF-SELECTION .  lcl_hello=>self->say_hello( ).

ABC

WRITE "Hello, world!"

ActionScript

ActionScript 1.0 and 2.0

This will output to the output window only, which an end user would not see.

trace("Hello, world!");

This version will be visible to the end user.

var helloWorld:TextField = this.createTextField( "helloWorld", this.getNextHighestDepth(), 1, 1, 100, 20 );helloWorld.text = "Hello, world!";

ActionScript 3

package{ public class HelloWorld { public function HelloWorld() { trace("Hello, world!"); } }}

Ada

with Ada.Text_IO; procedure Hello isbegin   Ada.Text_IO.Put_Line ("Hello, world!");end Hello;

ALGOL 68

The ALGOL 68 standard requires that reserved-words, types and operators are in a different typeface. Hence programs are typically published in either bold or an underline typeface, e.g.:

begin printf($"Hello, world!"l$)end

In the popular upper-case stropping convention for bold words:

BEGIN printf($"Hello, world!"l$)END

or using a wikitext like quote stropping, this is especially suitable on computers with only 6 bits per character (hence only have UPPERCASE):

'BEGIN' PRINTF($"HELLO, WORLD!"L$)'END'

or minimally using the "brief symbol" form of begin and end.

( printf($"Hello, world!"l$) )

AmigaE

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

AMX NetLinx

This program sends the message out via the Diagnostics Interface after start-up.

program_name = 'Hello'define_startsend_string 0,'Hello World!'

ANSI C

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

ANSI Common Lisp

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

ANT

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE project><project> <target name="helloworld"> <echo message="Hello, World!" /> </target></project>

APL

• The Del on the first line begins function definition for the program named HWΔPGM. It is a niladic function (no parameters, as opposed to monadic or dyadic) and it will return an explicit result which allows other functions or APL primitives to use the returned value as input.

• The line labeled 1 assigns the text vector 'Hello, world!!' to the variable R

• The last line is another Del which ends the function definition.

When the function is executed by typing its name the APL interpreter assigns the text vector to the variable R, but since we have not used this value in another function, primitive, or assignment statement the interpreter returns it to the terminal, thus displaying the words on the next line below the function invocation.

The session would look like this

  HWΔPGMHello, world!!

While not a program, if you simply supplied the text vector to the interpreter but did not assign it to a variable it would return it to the terminal as output. Note that user input is automatically indented 6 spaces by the interpreter while results are displayed at the beginning of a new line.

  'Hello, world!'Hello, world!!

AppleScript

return "Hello, world!"

or:

display dialog "Hello, world!"

ASP

<% Response.Write("Hello, world!") %>

or simply:

<%= "Hello, world!" %>

ASP.NET

// in the page behind using C#protected void Page_Load(object sender, EventArgs e){ Response.Write("Hello, world!");}

' in the page behind using VB.NETProtected Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs) Response.Write("Hello, world!")End Sub

// ASPX Page Template <asp:Literal ID="Literal1" runat="server" Text="Hello World!"></asp:Literal>

or

<asp:Label ID="Label1" runat="server" Text="Hello World"></asp:Label>

or

Hello World!

Assembly language

Accumulator-only architecture: DEC PDP-8, PAL-III assembler

See the example program in the Wikipedia PDP-8 article.

First successful uP/OS combinations: Intel 8080/Zilog Z80, CP/M, RMAC assembler

bdos equ 0005H ; BDOS entry pointstart:  mvi c,9  ; BDOS function: output string lxi d,msg$   ; address of msg call   bdos ret ; return to CCPmsg$:   db 'Hello, world!$'end start

Popular home computer: ZX Spectrum, Zilog Z80, HiSoft GENS assembler

 10  ORG #8000 ; Start address of the routine 20 START LD A,2   ; set the output channel 30  CALL #1601   ; to channel 2 (main part of TV display) 40  LD HL,MSG ; Set HL register pair to address of the message 50 LOOP LD A,(HL) ; De-reference HL and store in A 60  CP 0 ; Null terminator? 70  RET Z ; If so, return 80  RST #10  ; Print the character in A 90  INC HL   ; HL points at the next char to be printed100  JR LOOP110 MSG  DEFM "Hello, world!"120  DEFB 13  ; carriage return130  DEFB 0   ; null terminator

Accumulator + index register machine: MOS Technology 6502, CBM KERNEL, MOS assembler syntax

A_CR  = $0D  ;carriage returnBSOUT = $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

Accumulator/Index microcoded machine: Data General Nova, RDOS

See the example section of the Nova article.

Expanded accumulator machine: Intel x86, DOS, TASM

MODEL   SMALLIDEALSTACK   100H DATASEG MSG DB 'Hello, world!', 13, '$' CODESEGStart: MOV AX, @data MOV DS, AX MOV DX, OFFSET MSG MOV AH, 09H  ; DOS: output ASCII$ string INT 21H MOV AX, 4C00H INT 21HEND Start

ASSEMBLER x86 (DOS, MASM)

.MODEL Small.STACK 100h.DATA   db msg 'Hello, world!$'.CODEstart:   mov ah, 09h   lea dx, msg ; or mov dx, offset msg   int 21h   mov ax,4C00h   int 21hend start

ASSEMBLER x86 (DOS, FASM)

; FASM example of writing 16-bit DOS .COM program; Compile: "FASM HELLO.ASM HELLO.COM"   org  $100  use16  mov  ah,9  mov  dx,xhello  int  $21 ; DOS call: text output  mov  ah,$4C  int  $21 ; Return to DOSxhello db 'Hello world !!!$'

Expanded accumulator machine: Intel x86, Microsoft Windows, FASM

Example of making 32-bit PE program as raw code and data:

format PE GUIentry start section '.code' code readable executable start: push   0 push   _caption push   _message push   0 call   [MessageBox] push   0 call   [ExitProcess] section '.data' data readable writeable   _caption db 'Win32 assembly program',0  _message db 'Hello, world!',0 section '.idata' import data readable writeable   dd 0,0,0,RVA kernel_name,RVA kernel_table  dd 0,0,0,RVA user_name,RVA user_table  dd 0,0,0,0,0   kernel_table: ExitProcess dd RVA _ExitProcess dd 0  user_table: MessageBox dd RVA _MessageBoxA dd 0   kernel_name db 'KERNEL32.DLL',0  user_name db 'USER32.DLL',0   _ExitProcess dw 0 db 'ExitProcess',0  _MessageBoxA dw 0 db 'MessageBoxA',0 section '.reloc' fixups data readable discardable

Using FASM import macro, unicode (MessageBoxW is one of few unicode functions 'supported' by Windows 9x/ME) and section sharing, no relocation (not needed for executables), no heap - Not a beginners example but only 1024 instead of 3072 bytes:

include 'd:\dev\software\common\fasmw\win32a. inc' format PE GUI 4.0heap 0entry start section '.text' code import readable executable data  library kernel, 'KERNEL32.DLL',\ user,'USER32.DLL'   import kernel,\ ExitProcess, 'ExitProcess'  import user,\ MessageBoxW, 'MessageBoxW'   start: xor ebx, ebx push ebx push ebx push _message push ebx call [MessageBoxW] push ebx call [ExitProcess] _message du 'Hello, world!' ,0

Expanded accumulator machine: Intel x86, Linux, FASM

format ELF executableentry _start _start: mov eax, 4 mov ebx, 1 mov ecx, msg mov edx, msg_len int 80h  mov ebx, 0 mov eax, 1 int 80h  msg db 'Hello, world!', 0xA msg_len = $-msg

Expanded accumulator machine:Intel x86, Linux, GAS

.datamsg: .ascii "Hello, world!\n" len = . - msg.text .global _start_start: movl $len,%edx movl $msg,%ecx movl $1,%ebx movl $4,%eax int $0x80 movl $0,%ebx movl $1,%eax int $0x80

Expanded accumulator machine: Intel x86, Linux, NASM

 section .datamsg db  'Hello, world!',0xAlen equ $-msg section .textglobal  _start_start: mov edx,len mov ecx,msg mov ebx,1 mov eax,4 int 0x80 mov ebx,0 mov eax,1 int 0x80

Expanded accumulator machine: Intel x86, Linux, GLibC, NASM

extern printf ; Request symbol "printf".global main   ; Declare symbol "main". section .data  str: DB "Hello World!", 0x0A, 0x00 section .textmain:  PUSH str ; Push string pointer onto stack.  CALL printf ; Call printf.  POP eax ; Remove value from stack.  MOV eax,0x0 ; \_Return value 0.  RET ; /

General-purpose fictional computer: MIX, MIXAL

TERM EQU 19  console device no. (19 = typewriter) ORIG   1000 start addressSTART   OUT MSG(TERM)   output data at address MSG HLT halt executionMSG ALF "HELLO" ALF " WORL" ALF "D " END START   end of program

General-purpose fictional computer: MMIX, MMIXAL

string  BYTE   "Hello, world!",#a,0   string to be printed (#a is newline and 0 terminates the string)  Main  GETA   $255,string get the address of the string in register 255 TRAP   0,Fputs,StdOut put the string pointed to by register 255 to file StdOut TRAP   0,Halt,0   end process

General-purpose-register CISC: DEC PDP-11

RT-11, MACRO-11

 .MCALL  .REGDEF,.TTYOUT,.EXIT .REGDEFHELLO:  MOV #MSG,R1 MOVB   (R1)+,R0LOOP:  .TTYOUT MOVB   (R1)+,R0 BNE LOOP   .EXITMSG:   .ASCIZ  /Hello, world!/   .END HELLO

Variant for Elektronika BK using BIOS function, MICRO-11

 MOV #TXT,R1  ;Moving string address to R1 CLR R2   ;String length=0, means null will be the termination character EMT 20   ;Print the string HALTTXT: .ASCIZ  /Hello, world!/ .END

CISC Amiga (Workbench 2.0): Motorola 68000

 include lvo/exec_lib.i include lvo/dos_lib.i ; open DOS library movea.l  4.w,a6 lea  dosname(pc),a1 moveq #36,d0 jsr  _LVOOpenLibrary(a6) movea.l  d0,a6 ; actual print string lea  hellostr(pc),a0 move.l   a0,d1 jsr  _LVOPutStr(a6) ; close DOS library movea.l  a6,a1 movea.l  4.w,a6 jsr  _LVOCloseLibrary(a6) rts dosname dc.b 'dos.library',0hellostr dc.b 'Hello, world!',0

CISC Atari: Motorola 68000

;print move.l   #Hello,-(A7) move.w   #9,-(A7) trap #1 addq.l   #6,A7 ;wait for key move.w   #1,-(A7) trap #1 addq.l   #2,A7 ;exit clr.w   -(A7) trap #1 Hello dc.b 'Hello, world!',0

CISC Sharp X68000 (Human68K): Motorola 68000

 pea (strign) ; push string address onto stack dc.w $FF09  ; call DOS "print" by triggering an exception addq.l #4,a7 ; restore the stack pointer dc.w $FF00  ; call DOS "exit" strign: dc.b "Hello, world!",13,10,0

CISC on advanced multiprocessing OS: DEC VAX, VMS, MACRO-32

 .title hello .psect data, wrt, noexechan:   .blkw 1iosb:   .blkq 1term:   .ascid "SYS$OUTPUT"msg: .ascii "Hello, world!"len =   . - msg .psect code, nowrt, exe .entry hello, ^m<> ; Establish a channel for terminal I/O $assign_s devnam=term, -  chan=chan blbc  r0, end ; Queue the I/O request $qiow_s   chan=chan, -  func=#io$_writevblk, -  iosb=iosb, -  p1=msg, -  p2=#len ; Check the status and the IOSB status blbc  r0, end movzwl iosb, r0 ; Return to operating systemend: ret   .end   hello

Mainframe: IBM z/Architecture series using BAL

HELLO CSECT   The name of this program is 'HELLO' USING *,12  Tell assembler what register we are using SAVE (14,12) Save registers LR 12,15 Use Register 12 for this program   WTO   'Hello, world!' Write To Operator RETURN (14,12)  Return to calling party END  HELLO  This is the end of the program   

RISC processor: ARM, RISC OS, BBC BASIC's in-line assembler

.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:MOV PC,R14

RISC processor: MIPS architecture

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

RISC processor: PowerPC, Mac OS X, GAS

.datamsg: .ascii "Hello, world!\n" len = . - msg.text .globl _main_main: li r0, 4 ; write li r3, 1 ; stdout addis r4, 0, ha16(msg) ; high 16 bits of address addi r4, r4, lo16(msg) ; low 16 bits of address li r5, len ; length sc li r0, 1 ; exit li r3, 0 ; exit status sc

Sigma 6/7/8/9 METASYMBOL

   SYSTEM   BPMSTART  M:PRINT (MESS,HW)   M:EXITHW TEXTC 'HELLO WORLD'   END  START

AutoHotkey

MsgBox, Hello, world!

AutoIt

MsgBox(0,'','Hello, world!')

Avenue - Scripting language for ArcView GIS

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

AWK

BEGIN { print "Hello, world!" }

B

This is the first known Hello, world! program ever written:[1]

main( ) {  extrn a, b, c;  putchar(a); putchar(b); putchar(c); putchar('!*n');}a 'hell';b 'o, w';c 'orld';

Baan Tools

Also known as Triton Tools on older versions. On Baan ERP you can create a program on 3GL or 4GL mode.

3GL Format

function main(){ message("Hello, world!")}

4GL Format

choice.cont.process:on.choice: message("Hello, world!")

On this last case you should press the Continue button to show the message.

Bash or sh

echo 'Hello, world!'

or

printf 'Hello, world!\n'

or using the C preprocessor

#!/bin/bash#define cpp #cpp $0 2> /dev/null | /bin/bash; exit $?#undef cpp#define HELLO_WORLD echo "hello, world"HELLO_WORLD | tr a-z A-Z

BASIC

General

The following example works for any ANSI/ISO-compliant BASIC implementation, as well as most implementations built into or distributed with microcomputers in the 1970s and 1980s (usually some variant of Microsoft BASIC):

10 PRINT "Hello, world!"20 END

Note that the "END" statement is optional in many implementations of BASIC.

Some implementations could also execute instructions in an immediate mode when line numbers are omitted. The following examples work without requiring a RUN instruction.

PRINT "Hello, world!"

? "Hello, world!"

Later implementations of BASIC allowed greater support for structured programming and did not require line numbers for source code. The following example works when RUN for the vast majority of modern BASICs.

PRINT "Hello, world!"END

Again, the "END" statement is optional in many BASICs.

BlitzBasic

Print "Hello, world!"WaitKey

DarkBASIC

PRINT "Hello, world!"

or

TEXT 0,0,"Hello, world!"WAIT KEY

Note: In the "classic" Dark Basic the WAIT KEY command is optional as the console goes up when the program has finished.

FreeBasic

PRINT "Hello World"SLEEPEND

or

PRINT "Hello World"

or

? "Hello World"

or

'without a newline? "Hello World";

GW-BASIC

10 PRINT "Hello, World!"20 END

Liberty BASIC

To write to the main window:

PRINT "Hello, world"

Or drawn in a graphics window:

nomainwinOPEN "Hello, world!" FOR graphics AS #mainPRINT #main, "place 50 50"PRINT #main, "\Hello, world!"PRINT #main, "flush"WAIT

Microsoft Small Basic

TextWindow.WriteLine("Hello, world!")

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

PureBasic

 OpenConsole() PrintN("Hello, world!") INPUT()

or

MessageRequester("Hello, World","Hello, World")

or

Debug "Hello, World"

TI-BASIC

On TI calculators of the TI-80 through TI-86 range:

:Disp "Hello, world!  (note the optional ending quotes):Output(X,Y,"Hello, world! (note the optional ending parenthesis):Text(X,Y,"Hello, world!  (writes to the graph rather than home screen):Text(-1,X,Y,"Hello, world!   (only on the 83+ and higher, provides larger text, home screen size):"Hello, world!   (last line of program only)

Note: "!" character is not on the keypad. It can be accessed from "Catalog" or the "Probability" menu (as factorial notation).

On TI-89/TI-89 Titanium/TI-92(+)/Voyage 200 calculators:

:hellowld():Prgm:Disp "Hello, world!":EndPrgm

Visual Basic

Private Sub Form_Load()  MsgBox "Hello, world"End Sub

Alternatively, copy this into a New Form:

Private Sub Form_Click()   Form1.Hide   Dim HelloWorld As New Form1   HelloWorld.Width = 2500: HelloWorld.Height = 1000: HelloWorld.Caption = "Hello, world!": HelloWorld.CurrentX = 500: HelloWorld.CurrentY = 75   HelloWorld.Show: HelloWorld.Font = "Tahoma": HelloWorld.FontBold = True: HelloWorld.FontSize = 12: HelloWorld.Print "Hello, world!"End Sub

Visual Basic .NET

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

PICK/BASIC, DATA/BASIC, MV/BASIC

In addition to the ANSI syntax at the head of this article, most Pick operating system flavors of Dartmouth BASIC support extended syntax allowing cursor placement and other terminfo type functions for VDT's

X, Y positioning (colon ":" is the concatenation instruction):

 PRINT @(34,12) : "Hello, world!" 

Will display the string "Hello, world!" roughly centered in a 80X24 CRT.

Other functions:

 PRINT @(-1) : @(34,12) : "Hello, world!"

Will clear the screen before displaying the string "Hello, world!" roughly centered in a 80X24 CRT.

Syntax variants:

 CRT "Hello, world!"

Supporting the "@" functions above, the CRT statement ignores previous PRINTER statements and always sends output to the screen.

Some Pick operating system environments such as OpenQM support the DISPLAY variant of PRINT. This variant in addition to the "@" functions maintains pagination based upon the settings of the TERM variable:

 DISPLAY "Hello, world!"

Batch (MS-DOS)

@echo Hello World!

or

@echo offset hellostring=Hello World!echo %hellostring%or<source lang="dod">@echo offecho Hello World!pauseexit

bc

"Hello, world!"

or, with the newline

print "Hello, world!\n"

BCPL

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

BITGGAL AgileDog

T  1 "Hello, World" 0

BITGGAL Jihwaja

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

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;ENDELUDOM

BlitzMax

SuperStrictGraphics 640, 480, 0, 60Local running:Int = 1While running Cls DrawText "Hello World!", 1, 1 Flip If GetChar() running = 0 EndIfWendEnd

boo

See also GUI section.

print "Hello, world!"

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'

Burning Sand 2

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

C

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

Caché Server Pages (CSP)

Class Test.Hello Extends %CSP.Page [ ProcedureBlock ]{   ClassMethod OnPage() As %Status   {   &html<<html>   <head>   </head>   <body>>   Write "Hello, world!",!   &html<</body>   </html>>   Quit $$$OK   }}

Calprola

This program will work on the Avasmath 80 online programmable calculator.

#BTN A1#PRI "HELLO WORLD!"#END

C/AL - MBS Navision

OBJECT Codeunit 50000 HelloWorld{  PROPERTIES  { OnRun=BEGIN MESSAGE(Txt001);  END;  }  CODE  { VAR  Txt001@1000000000 : TextConst 'ENU=Hello, world!'; BEGIN {  Hello, world! in C/AL (Microsoft Business Solutions-Navision) } END.  }}

Casio FX-9750

This program will work on the fx-9750 graphing calculator and compatibles.

"Hello, world!"↵

or

Locate 1,1,"Hello, world!"↵

CCL

 call echo("Hello, world!")

Ch

The above C code can run in Ch as examples. The simple one in Ch is:

 printf("Hello, world!\n");

Chuck

 <<<"Hello World">>>

Chrome

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

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

CintieFramework (VisualBasic.NET)

<Script> <References> <Reference>System.dll</Reference> </References> <Code Language="VisualBasic"><![CDATA[Public Class Plugin Public Function MainF(ByVal Ob As Object) As String 'Script Code Return "Hello, World!" End FunctionEnd Class]]> </Code></Script>

Clean

module helloStart = "Hello, world!"

Clipper

? "Hello, world!"

or

@1,1 say "Hello, world!"

or

Qout("Hello, world")

CLIST

PROC 0WRITE Hello, world!

Clojure

(println "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.PROCEDURE DIVISION. DISPLAY "Hello, world!" STOP RUN.

The above is a very abbreviated and condensed version, which omits the author name and source and destination computer types.

ColdFusion (CFML)

<cfoutput>Hello, world!</cfoutput>

or

Hello, world!

COMAL

PRINT "Hello, world!"

Common Lisp

 (princ "Hello, world!")

Cube

Function | Main  WriteLine | "Hello, world"End | Main

The '|' refers to the separation of the two text fields in the Cube standard IDE.

C++

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

C++/CLI

int main(){   System::Console::WriteLine("Hello, world!");   return 0;}

C++, Managed (.NET)

#using <mscorlib.dll> using namespace System; int wmain(){ Console::WriteLine("Hello, world!"); return 0;}

C#

See also GUI section.

using System; internal static class HelloWorld{ private static void Main() { Console.WriteLine("Hello, world!"); }}

Or just in one line:

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

D

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

Tango version:

 import tango.io.Stdout;  void main() { Stdout ("Hello, world!").newline; }

DC, an arbitrary precision calculator

[Hello, world!]p

or

1468369091346906859060166438166794P

DCL batch

$ write sys$output "Hello, world!"

D++

function main(){ screenput "Hello, world!";}

Delphi

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

DIV

PROGRAM hello;BEGIN write(0, 0, 0, 0, "Hello, world!"); LOOP FRAME; ENDEND

DOLL

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

Dream Maker

mob Login() ..() world << "Hello, world!"

Dylan

module: helloformat-out("Hello, world!\n");

EAScripting

set disp to "Hello, world!"set dispto to item unit 5 //5 = default screenrelease disp into dispto.

This would be a pure system call

import system ea.helloworldwait

Ed and Ex (Ed extended)

aHello, world!!.p

Eiffel

class HELLO_WORLD create makefeature make is do io.put_string("Hello, world!%N") end -- makeend -- class HELLO_WORLD

Erlang

See also GUI section.

-module(hello). -export([hello/0]). hello() -> io:format("Hello, world!~n").

Euphoria

puts(1, "Hello, world!")

Factor

"Hello, world!" print

or gui version

"Hello, world!" <label> "Hi" open-window

Falcon

printl( "Hello world" )

Ferite

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

filePro

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

Fjölnir

"halló" < main{   main ->   stef(;)   stofn   skrifastreng(;"Halló, veröld!"),   stofnlok}*"GRUNNUR";

FOCAL

type "Hello, world!",!

or

t "Hello, world!",!

Focus

-TYPE Hello, world!

Forte TOOL

begin TOOL HelloWorld;includes Framework;HAS PROPERTY IsLibrary = FALSE;forward  Hello;-- START CLASS DEFINITIONSclass Hello inherits from Framework.Objecthas 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-------------------------- ----------------------------------met hod Hello.Initbeginsuper.Init();task.Part .LogMgr.PutLine('Hello, world!');end method;-- END METHOD DEFINITIONSHAS PROPERTY CompatibilityLevel = 0; ProjectType = APPLICATION; Restricted = FALSE; MultiThreaded = TRUE; Internal = FALSE; LibraryName = 'hellowor'; StartingMethod = (class = Hello, method = Init);end HelloWorld;

Forth

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

or instead of compiling a new routine, one can type directly in the Forth interpreter console

 CR ." Hello, world!" CR

Fortran

Fortran 77

00 program hello  write(*,*) 'Hello World!'  stop  end

Fortran 90/95

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

F#

print_endline "Hello, world!"

or

printfn "Hello, world!"

Fril

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

or

pp "Hello, world!"

Frink

println["Hello, world!"]

Gambas

See also GUI section.

PUBLIC SUB Main()  Print "Hello, world!"END

GEMBase 4GL

procedure_form hello  begin_block world  print "Hello, world!"  end_blockend_form

GML (Game Maker Language)

In the draw event of some object:

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

Or to show a splash screen message:

show_message("Hello, world!")

Go (from Google)

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

GraalScript

GraalScript 1

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

GraalScript 2

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

Groovy

println "Hello, world!"

Harbour

? "Hello, world!"

or

@1,1 say "Hello, world!"

or

Qout("Hello, world")

Haskell

main = putStrLn "Hello, world!"

haXe

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

Heron

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

HP 33s

(Handheld Hewlett-Packard RPN-based scientific calculator.)

LBL HSF 10EQNRCL HRCL ERCL LRCL LRCL OR/SRCL WRCL ORCL RRCL LRDL DENTERR/S

HP-41 & HP-42S

(Handheld Hewlett-Packard RPN-based alphanumeric engineering calculators.)

01 LBLTHELLO02 THello, world!03 PROMPT

HyperTalk (Apple HyperCard's scripting programming language)

put "Hello, world!"

or

Answer "Hello, world!"

Icon

procedure main() write("Hello, world!")end

IDL

print,"Hello, world!"

Io

"Hello, world!" println

or

writeln("Hello, world!")

Inform

Inform 5/6

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

Inform 7

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

Iptscrae

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

J

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

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

Jal

include 16f877_20include 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

See also GUI section.

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:   returnpublic static void main(java.lang.String[]); Code:  0:   getstatic   #2; //Field java/lang/System.out:Ljava/io/PrintSt ream;  3:   ldc #3; //String Hello, world!  5:   invokevirtual   #4; //Method java/io/PrintStream.println:(Ljava/la ng/String;)V  8:   return}

JavaFX Script

JavaFX Script was a scripting language formerly called F3 for Form Follows Function. It was discontinued by Oracle in 2010.

Frame {   title: "Hello World JavaFX"   width: 200   content: Label {  text: "Hello World"   }   visible: true}

This program can also be written in this way:

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;

A simple console output version would be:

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

Or even simpler (with a built-in function):

println("Hello World");

JavaScript

JavaScript does not have native (built in) input or output routines. Instead it relies on the facilities provided by its host environment.

Using a standard Web browser's document object

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

or with an alert, using a standard Web browser's window object (window.alert)

alert('Hello, world!');

or, from the Mozilla command line implementation

print('Hello, world!');

or, from the Windows Script Host

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

or, from Firebug, Apple Safari, or Google Chrome debug console

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

Joy

"Hello, world!\n" putchars .

JSP

<%@ page contentType="text/html;charset=WINDOW S-1252"%><HTML>   <BODY> <% out.println(" Hello, world!"); %>   </BODY></HTML>

or just

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

or literally

 Hello, world!

K

`0:"Hello, world!\n"

Kogut

WriteLine "Hello, world!"

KPL (Kids Programming Language)

Program HelloWorld   Method Main()  ShowConsole()  ConsoleWriteLine("Hello, world!")   End MethodEnd Program

Lasso

Output: 'Hello, world!';

or

Output('Hello, world!');

or simply

'Hello, world!';

Lexico Mobile (in spanish)

tarea muestre "Hola mundo !"

or

clase Saludo derivada_de FormpublicosmensajesSaludo copie "Hola mundo !" en saludo.Text

Linden Scripting Language

Linden Scripting Language is the scripting language used within Second Life

default{ state_entry() { llSetText("Hello, World!" , <0,0,0> , 1.0); //or... llSay(0,"Hello, World!"); }}

Linotte

Livre : HelloWorld Paragraphe : Affichage Actions :   "Hello, World !" !

Lisaac

Section Header  + name := HELLO_WORLD_PROGRAM; Section Public  - main <-  ( "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 in the REPL:

"Hello, world!"

(As a string (enclosed in quotes) it evaluates to itself, so is printed.)

Scheme

(display "Hello, world!\n")

Clojure

(println "Hello, world!")

Emacs Lisp

(print "Hello, world!")

or:

(message "Hello, world!")

AutoLisp

(print "Hello, world!")

XLISP

(print "Hello, world!")

Arc

(prn "Hello, world!")

Pils

(out "Hello, world!")

Logo

print [Hello, world!]

or

pr [Hello, world!]

In mswlogo only

messagebox [Hi] [Hello, world!]

LPC

  void create()  {  write("Hello, world!\n");  }

Lua

io.write("Hello, world!\n")

or

return "Hello, World!"

or

print("Hello, world")

LuaDEV (psp and wii)

screen.print(10,10,"Hello, world!")

M (MUMPS)

W "Hello, world!"

Macsyma, Maxima

print("Hello, world!")$

Maple

print("Hello, world!");

Mathematica

Print["Hello, world!"]

or simply:

"Hello, world!"

MATLAB

disp('Hello, world!')

or

fprintf('Hello, world!')

or with a GUI

 figure('Position',[100 100 200 200],'MenuBar','none','Name','Hello World'); uicontrol('Style','text','Position',[15 100 150 15],'String','Hello world');

or

msgbox('Hello World!')

Maude

fmod HELLOWORLD isprotecting STRING .  op helloworld : -> String .  eq helloworld = "Hello, world!" .endfmred 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;

Maya Embedded Language

print( "Hello, world!\n" );

Mesham

var x:String::allocated[on[0]];x:="Hello World";  // allocated on process 0 onlyproc 1 {   // This is displayed by process 1, auto communication done to achieve this   print[x];}

M4

Hello, world!

mIRC Script

aliases

helloworld echo Hello, world!

remote

alias helloworld echo Hello, world!

popups

Hello World:echo Hello, world!

command line

/echo Hello, world!

or

//echo Hello, world!

Model 204

BEGINPRINT 'Hello, world!'END

Modula-2

MODULE Hello;FROM InOut IMPORT WriteLn, WriteString;BEGIN   WriteString ("Hello, world!");   WriteLnEND Hello.

Monkey

StrictFunction Main:Int() Print "Hello World!"  Return 0End

MOO

This requires that you be the player or a wizard:

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

This is specific to the implementation of the core used for the moo, but works on most well known moos, such as LambdaCore or JH-Core:

player:tell("Hello, world!");

Mouse

"Hello, World!"$

MPI

#include <stdio.h>#include <time.h>#include <string.h>#include "mpi.h"int main ( int argc, char * argv[] ){ const int   maximum_message_length = 100; const int   master_rank =   0; char message[maximum_message_length+1]; MPI_Status  status;  /* Info about receive status  */ int my_rank; /* This process ID */ int num_procs;   /* Number of processes in run */ int source;  /* Process ID to receive from */ int destination; /* Process ID to send to  */ int tag = 0; /* Message ID */ int mpi_error;   /* Error code for MPI calls   */ int icount; char processor_name[MPI_MAX_PROCESSOR_NAME ]; int name_length; // Initialize the MPI execution environment. mpi_error = MPI_Init ( &argc, &argv ); if ( mpi_error != MPI_SUCCESS ) { fprintf ( stderr, "Error: %s: Unable to initialize MPI execution environment\nAborting ...\n", argv[0] ); return ( 1 ); } // Even though we capture the error value from the MPI calls, we will // not deal with any error except the last one. mpi_error = MPI_Comm_rank ( MPI_COMM_WORLD, &my_rank ); mpi_error = MPI_Comm_size ( MPI_COMM_WORLD, &num_procs ); if ( my_rank != master_rank ) { mpi_error = MPI_Get_processor_name (processor_name, &name_length ); sprintf ( message, "Greetings from process #%d running on %s\n", \  my_rank, processor_name ); destination = master_rank; mpi_error = MPI_Send ( message, strlen(message) + 1, MPI_CHAR,  \ destination, tag, MPI_COMM_WORLD ); } else { for ( source = 0; source < num_procs; source++ ) { if ( source != master_rank ) { mpi_error = MPI_Recv ( message, maximum_message_length + 1, \ MPI_CHAR, source, tag, MPI_COMM_WORLD, &status ); printf ( "%s  \n", message ); } } } mpi_error = MPI_Finalize(); if ( MPI_SUCCESS != mpi_error ) return ( mpi_error ); else return ( 0 );}

M# Fictional Computer Language

Script

main(std:string >>arg<< / OS.GetArg){ std:stream >>CONSOLE<< / OS.Console; CONSOLE:Write([byte]{0048, 0065, 006C, 006C, 006F, 002C, 0058, 006F, 0072, 006C, 0064}); // H e l l o , W o r l d   //}

Command WI

# # DEFINE g >>CONSOLE<< / OS.Console# % proc CONSOLE:Write([byte]{0048, 0065, 006C, 006C, 006F, 002C, 0058, 006F, 0072, 006C, 0064})

Command WoI

# @ Write([byte]{0048, 0065, 006C, 006C, 006F, 002C, 0058, 006F, 0072, 006C, 0064})

MS-DOS batch

(with the standard command.com interpreter. The @ symbol is optional and prevents the system from repeating the command before executing it. The @ symbol must be omitted on versions of MS-DOS prior to 3.0.). It's very common for batchfiles to start with two lines of "@echo off" and "cls".

 @echo Hello, world!

For MS-DOS 3.0 or lower

echo offclsecho Hello, world!

MUF

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

Natural

WRITE 'Hello, world!'END

or

WRITE 'Hello, world!'.

Neko

$print("Hello, world!!\n");

Nemerle

The easiest way to get Nemerle print "Hello, world!" would be that:

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

however, in bigger applications the following code would be probably more useful:

using System.Console;module HelloWorld{   Main():void   {  WriteLine("Hello, world!");   }}

Oberon

Oberon is both the name of a programming language and an operating system.

Program written for the Oberon operating system:

MODULE Hello; IMPORT Oberon, Texts; VAR W: Texts.Writer; PROCEDURE World*; BEGIN   Texts.WriteString(W, "Hello, world!");   Texts.WriteLn(W);   Texts.Append(Oberon.Log, W.buf) END World;BEGIN Texts.OpenWriter(W)END Hello.

Freestanding Oberon program using the standard Oakwood library:

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

Obix

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

Objective C

Procedural C Version

#import <stdio.h> int main (int argc, const char *argv[]){ printf ("Hello, world!\n"); return 0;}

Object-Oriented C Version

#import <stdio.h>#import <objc/Object.h>  @interface Hello : Object{}- hello;@end  @implementation Hello- hello{   printf("Hello, world!\n");}@end  int main(void){   id obj;   obj = [Hello new];   [obj hello];   [obj 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!):

or without using course.lib

PROC hello.world(CHAN OF BYTE screen!)  SEQ screen ! 'H' screen ! 'e' screen ! 'l' screen ! 'l' screen ! 'o' screen ! ',' screen ! ' ' screen ! 'w' screen ! 'o' screen ! 'r' screen ! 'l' screen ! 'd' screen ! '!' screen ! '*n':

OpenScript

-- in a popup windowrequest "Hello world"

OPL

See also GUI section.

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!'}

Parrot assembly language

print "Hello, world!\n"end

Parrot intermediate representation

.sub hello :main  print "Hello, world!!\n".end

Pascal

program helloworld;begin   writeln('Hello, world!')end.

PAWN

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

or

main() { new string[14]; format string(sizeof(string), "Hello, World!); print(string);}

Perl

As PL file

 print "Hello, world!\n";

(the semicolon is optional)

or

 package Hello; sub new() { bless {} } sub Hello() { print "Hello, world! \n" } package main; my $hello = new Hello; $hello->Hello();

As CGI file

#!/usr/local/bin/perlprint "Content-type: text/html\n\n";print "<H1>Hello World!</H1>";

Perl 6

"Hello, world!".say

or

say "Hello, world!";

or

print "Hello, world!\n";

PHP

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

or use short-hand echoing, syntaxed as such:

<? echo "Hello, world!"?>

Pike

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

PILOT

T:Hello, world!

PL/SQL

SET serveroutput ON size 1000000;  -- this is a SQL*Plus command to enable the output bufferBEGIN DBMS_OUTPUT.put_line('Hello, world!'); END;

PL/I

Test: proc options(main);  put list('Hello, world!');end Test;

PostScript

See also page description language section.

(Hello, world!\n) print

Processing

println("Hello, world!");

Progress 4GL

display "Hello, world!".

Prolog

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

Pure Data

#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;

Python

'Hello, World!' (with quotation marks) can be attained through:

'Hello, world!'

Two easter eggs (Python 2.0):

import __hello__ import __phello__

Prior to Python 3.0:

print "Hello, world!"

Python 3.0 or later:

print("Hello, world!")

or any Python version

import syssys.stdout.write("Hello, world!\n")

R

print('Hello, world!')

R

Rebol

See also GUI section.

print "Hello, world!"

Redcode

; Should work with any MARS >= ICWS-86; with 128x64 gfx coreStart MOV 0,2455  MOV 0,2458  MOV 0,2459  MOV 0,2459  MOV 0,2459  MOV 0,2459  MOV 0,2459  MOV 0,2460  MOV 0,2465  MOV 0,2471  MOV 0,2471  MOV 0,2471  MOV 0,2479  MOV 0,2482  MOV 0,2484  MOV 0,2484  MOV 0,2484  MOV 0,2486  MOV 0,2486  MOV 0,2486  MOV 0,2486  MOV 0,2488  MOV 0,2493  MOV 0,2493  MOV 0,2493  MOV 0,2493  MOV 0,2497  MOV 0,2556  MOV 0,2559  MOV 0,2560  MOV 0,2565  MOV 0,2570  MOV 0,2575  MOV 0,2578  MOV 0,2585  MOV 0,2588  MOV 0,2589  MOV 0,2592  MOV 0,2593  MOV 0,2596  MOV 0,2597  MOV 0,2603  MOV 0,2605  MOV 0,2608  MOV 0,2667  MOV 0,2670  MOV 0,2671  MOV 0,2676  MOV 0,2681  MOV 0,2686  MOV 0,2689  MOV 0,2696  MOV 0,2699  MOV 0,2700  MOV 0,2703  MOV 0,2704  MOV 0,2707  MOV 0,2708  MOV 0,2714  MOV 0,2716  MOV 0,2719  MOV 0,2778  MOV 0,2778  MOV 0,2778  MOV 0,2778  MOV 0,2778  MOV 0,2779  MOV 0,2779  MOV 0,2779  MOV 0,2782  MOV 0,2787  MOV 0,2792  MOV 0,2795  MOV 0,2802  MOV 0,2805  MOV 0,2806  MOV 0,2809  MOV 0,2810  MOV 0,2810  MOV 0,2810  MOV 0,2810  MOV 0,2812  MOV 0,2818  MOV 0,2820  MOV 0,2823  MOV 0,2882  MOV 0,2885  MOV 0,2886  MOV 0,2891  MOV 0,2896  MOV 0,2901  MOV 0,2904  MOV 0,2911  MOV 0,2912  MOV 0,2913  MOV 0,2914  MOV 0,2917  MOV 0,2918  MOV 0,2919  MOV 0,2922  MOV 0,2928  MOV 0,2930  MOV 0,2933  MOV 0,2992  MOV 0,2995  MOV 0,2996  MOV 0,3001  MOV 0,3006  MOV 0,3011  MOV 0,3014  MOV 0,3021  MOV 0,3022  MOV 0,3023  MOV 0,3024  MOV 0,3027  MOV 0,3028  MOV 0,3030  MOV 0,3032  MOV 0,3038  MOV 0,3040  MOV 0,3103  MOV 0,3106  MOV 0,3107  MOV 0,3107  MOV 0,3107  MOV 0,3107  MOV 0,3107  MOV 0,3108  MOV 0,3108  MOV 0,3108  MOV 0,3108  MOV 0,3108  MOV 0,3109  MOV 0,3109  MOV 0,3109  MOV 0,3109  MOV 0,3109  MOV 0,3111  MOV 0,3111  MOV 0,3111  MOV 0,3120  MOV 0,3121  MOV 0,3124  MOV 0,3124  MOV 0,3124  MOV 0,3126  MOV 0,3129  MOV 0,3130  MOV 0,3130  MOV 0,3130  MOV 0,3130  MOV 0,3130  MOV 0,3131  MOV 0,3131  MOV 0,3131  MOV 0,3131  MOV 0,3135  JMP 0

REFAL

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

Revolution

(This works the same for Transcript or xTalk)

Printed in the message box

put "Hello, World!" 

Shown within a dialog box

answer "Hello, world!" 

Printed on the main window interface

create field "myField"set the text of field "myField" to "Hello, world!"  

As CGI file

#!revolution on startup   put "Content-Type: text/plain" & cr & cr   put "Hello World!" end startup 

REXX, ARexx, NetRexx, and Object REXX

/* a starting comment is needed in mainframe versions */say "Hello, world!"

RPG

Free-Form Syntax

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

Traditional Syntax

With this syntax, a constant has to be used because the message must be placed in positions 12 to 25, between apostrophes.

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

RPG Code

Message Window

Using the internal message window, a simple Hello, world! program can be rendered thus:

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

On Screen Text

An additional way to render text is by using the built in text() function.

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

RPL

See also GUI section.

(On Hewlett-Packard HP-28, HP-48 and HP-49 series graphing calculators.)

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

RT Assembler

_name   Hello~World!pause   Hello~World!exit_end

Ruby

See also GUI section.

 puts 'Hello, world!'

or

 'Hello, world!'.each { |s| print s }

or

 class String def say puts self end end 'Hello, world!'.say

S (and R)

print("Hello, world")

or

message("Hello, world")

S-Lang

message("Hello, world!");

SAS

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

Sather

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

Scala

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

SCAR

program HelloWorld;begin WriteLn('Hello world!');end.

Scheme

(display "Hello, World!\n")

Scratch

sed

(note: requires at least one line of input)

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.

sense script

out('Hello, world!');

ShadowScript

'set up initial variablesstruct.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 windowopen mainwin(io<std>) as free(1) {  write.free(1).("Hello",&sym," world",&sym)(&sym<",">& amp;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)>'endend.end/

Simula

BEGIN OutText("Hello, world!"); OutImage;END

Smalltalk

Transcript show: 'Hello, world!'

alternative:

StdoutStream nextPutLine: 'Hello, world'

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;isbegin  Spark_IO.Put_Line (Spark_IO.Standard_Output, "Hello, world!", 0);end Hello_World;

Spin

Spin is the high level language from Parallax Inc. used to program their Propeller multi-core micro-controllers.

The program assumes that the software UART object, provided with the Propeller IDE, is used to deliver the message over a serial line.

CON _clkmode = xtal1 + pll16x _xinfreq = 5_000_000OBJ console : "FullDuplexSerial"PUB start console.start(31, 30, 0, 115_200) console.str(string("Hello, world!", 13))

SPITBOL

 OUTPUT = "Hello, world!"END

SPSS Syntax

ECHO "Hello, world!".

SSPL

1.0print Hello, World!end

Standard ML

print "Hello, world!\n";

SQL

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

or (for EnterpriseDB's Stored Procedure Language (SPL))

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

or (e.g. Oracle dialect)

SELECT 'Hello, world!' FROM dual;

or (for Oracle's PL/SQL proprietary procedural language)

 BEGIN   DBMS_OUTPUT.ENABLE(1000000);   DBMS_OUTPUT.PUT_LINE('Hello, world!'); END;

or (e.g. MySQL or PostgreSQL dialect)

SELECT 'Hello, world!';

or (for PostgreSQL's PL/pgSQL Procedural language)

 CREATE FUNCTION hello_world() RETURNS text AS $$   BEGIN  RETURN 'Hello, world!';   END $$ LANGUAGE plpgsql;

or (e.g. T-SQL dialect)

PRINT 'Hello, world!'

or (for KB-SQL dialect)

 SELECT NULL FROM DATA_DICTIONARY.SQL_QUERY  FOOTER ''OR HEADER OR DETAIL OR FINAL event'' WRITE "Hello, world!"

STARLET

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

Stata

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

capture program drop hello /*Define Hello, world! program*/program define hello di "Hello, world!"endhello  /*run Hello, world! program*/

Or, interactively at the command line:

di "Hello, world!"

SuperCollider

"Hello, world!".postln;

or, for interactive prompt,

"Hello, world!"

TACL

#OUTPUT Hello, world!

TBS(To Be Simple)

!out(~"Hello, world!");_die();

Tcl (Tool command language)

See also GUI section.

puts "Hello, world!"

Template Toolkit

[% GET "Hola mundo!"; %]

Thyme

 print ("Hello, world!")

TOM (rewriting language)

public class HelloWorld { %include { string.tom } public final static void main(String[] args) {   String who = "world";   %match(String who) { "World" -> { System.out.println("Hello, " + who + "!"); } _   -> { System.out.println("Don't panic"); }   } }

TSQL

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

or, simpler variations:

Select 'Hello, world!'Print 'Hello, world!'

TTCN-3

module hello_world {  control { log("Hello, world!");  }}

Turing

put "Hello world!"

UNIX-style 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

Vala

using GLib; public int main(string[] args){   stdout.printf("Hello, world!\n");   return 0;}

Verilog

module main();   initial begin  #0 $display("Hello, world!!");  #1 $finish;   endendmodule

or (a little more complicated)

module hello(clk);   input clk;   always @(posedge clk) $display("Hello, world!!");endmodulemodule main();   reg clk;   hello H1(clk);   initial begin  #0 clk=0;  #5 clk=1;  #1 $finish;   endendmodule

module hello(clk);   input clk;   always @(posedge clk) $display("Hello, world!!");endmodulemodule main();   reg clk;   hello H1(clk);   initial begin  #0 clk=0;  #23 $display("--23--");  #100 $finish;   end   always #5 clk=~clk;endmodule

VHDL

use std.textio.all;entity Hello isend Hello;architecture Hello_Arch of Hello isbegin   p : process   variable l:line;   begin   write(l, String'("Hello, world!"));   writeline(output, l);   wait;   end process;end Hello_Arch;

Visual Basic Script

WScript.Echo "Hello, world!"

Visual Prolog

#include @"pfc\console\console.ph"goal  console::init(),  stdio::write("Hello, world!").

Windows PowerShell

"Hello, world!"

or

Write-Host "Hello, world!"

or

echo "Hello, world!"

or

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

or

[void][System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms')[System.Windows.Forms.MessageBox]::Show("Hello, World!")

X#

sub:mainload:mscorlib.dllpush:Hello, World!invoke:mscorlib.dll:System.Cons ole:Write:1endsub

XC

XC is a C like language from XMOS Ltd offering features supporting Communicating Sequential Processes on their multi-threaded, multi-core processors. This example shows some of those features.

#include <platform.h>#define BIT_RATE 115200#define BIT_TIME XS1_TIMER_HZ / BIT_RATE // A one bit output port with bufferingout port:1 buffered uart_tx = PORT_UART_TX; // Thread implements serial transmitter using the ports timer.void console (chanend c, out port:1 buffered TXD){ unsigned time; char byte; while (1) { c :> byte;  // Read byte from the consol output channel. TXD <: 0 @ time; // Set start bit and save IO time stamp. for (int j = 0; j < 8; j += 1)  // Data bits. { time += BIT_TIME;   // Time of next bit. TXD @ time <: >> byte;  // Shift out next bit on time. } time += BIT_TIME;   // Two stop bits TXD @ time <: 1; time += BIT_TIME; TXD @ time <: 1; }} // Thread issues greeting message to the consolevoid greeter(chanend c){ char msg[] = "Hello World!\n"; int i; while (1)   // Repeatedly send message to console output channel. { for (i = 0; i < sizeof(msg) - 1; i++) { c <: msg[i]; // Output a byte to the channel. } }} int main(){ chan c; // Communication channel between threads. par // Parallel execution of block statements. { on stdcore[0]: console(c, uart_tx); // Run console output thread on core 0. on stdcore[1]: greeter(c);  // Run greeter thread or core 1. } return 0;}

XL

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

or

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

XMLmosaic

<Class>  <Type>XMLmosaic Class</Type>  <Method> <Name id="1">Main</Name> <Code id="1">void Main(){Console.WriteLine('Hello World!');} </Code>  </Method>  <Counter> <Count>1</Count>  </Counter></Class>

Yorick

write, "Hello, world!";

Note: The semicolon is optional.

Zdzich

Programming language with commands in Polish. Webpage

pisz Hello World!koniec

Graphical user interfaces (GUIs)

ActionScript (Adobe Flash)

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

AppleScript

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

boo

import System.Drawingimport System.Windows.Formsf = Form()f.Controls.Add(Label(Text: "Hello, world!", Location: Point(40,30)))f.Controls.Add(Button(T ext: "Ok", Location: Point(50, 55), Click: {Application.Exit()}))Application.Run (f)

Functional equivalent of C# program below.

C#

Simply, using Message Box:

 public class HelloWorld { static void Main() { System.Windows.Forms.MessageBox.Show("Hello, world!"); } }

Or:

using System;using System.Drawing;using System.Windows.Forms;  public class HelloWorldForm : Form  { public static void Main()  { Application.Run(new HelloWorldForm()); }  public HelloWorldForm()  { Label label = new Label(); label.Text = "Hello, world!"; label.Location = new Point(40,30); this.Controls.Add(label); Button button = new Button(); button.Text = "OK"; button.Location = new Point(50,55); this.Controls.Add(button); button.Click += new EventHandler(button_Click); }  private void button_Click(Object sender, EventArgs e)  { Application.Exit(); } }

Clarion

The simplest way to achieve this is with the built in message function that is similar to the windows messageBox().

   PROGRAM   MAP   END   CODE   MESSAGE('Hello, world!!','Clarion')   RETURN

A more real world example uses a Clarion structure to declare a window and the Clarion Accept loop to process events from that window.

  PROGRAM MAPHelloProcedure  PROCEDURE() END CODE HelloProcedure() RETURNHelloProcedure  PROCEDURE()Window WINDOW('Clarion for Windows'),AT(,,222,116),FONT('Tahoma' ,8,,FONT:regular),ICON('Hey.ICO'), | SYSTEM,GRAY   STRING('Hello, world!!'),AT(91,22),USE(?String1)   BUTTON('Close'),AT(92,78,37,14),USE(? CloseBtn),LEFT END CODE OPEN(Window) ACCEPT  CASE ACCEPTED()  OF ?CloseBtn POST(EVENT:CloseWindow)  END END CLOSE(Window) RETURN

Cocoa or GNUStep (In Objective C)

#import <Cocoa/Cocoa.h>@interface hello : NSObject {}@end @implementation hello -(void)awakeFromNib{  NSBeep(); // we don't need this but it's conventional to beep    // when you show an alert NSRunAlertPanel(@"Message from your Computer", @"Hello, world!", @"Hi!", nil, nil);} @end

Curl

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

Delphi, Kylix

program Hello_World;uses  QDialogs; begin   ShowMessage('Hello, world!'); or   MessageDlg ('Hello, world!', mtInformation, [mbOk], 0);  end.

Erlang

-module(hello_world).-export([hello/0 ]).hello() ->   S = gs:start(),   Win = gs:create(window, S, [{width, 100}, {height, 50}]),   gs:create(label, Win, [{label, {text, "Hello, world!"}}]),   gs:config(Win, {map, true}),   receive  {gs, Win, destroy, _, _} -> gs:stop()   end,   ok.

One way of invoking this would be to enter hello_world:hello(). in the Erlang shell; another would be to run from a command line:

erl -noshell -run hello_world hello -run init stop

Euphoria

MS-Windows only - basic.

include msgbox.eif message_box("Hello, world!", "Hello", 0) then end if

MS-Windows only - using Win32Lib library

include win32lib.ewcreateForm({   ";Window; Hello",   ";Label;  Hello, world!"   })include w32start.ew

F#

Using WindowsForms, at the F# interactive prompt:

let _ = System.Windows.Forms.MessageBox.Show( "Hello, world!");

FLTK2 (in C++)

#include <fltk/Window.h>#include <fltk/Widget.h>#include <fltk/run.h>using namespace fltk; int main(int argc, char **argv){ Window *window = new Window(300, 180); window->begin(); Widget *box = new Widget(20, 40, 260, 100, "Hello, world!"); box->box(UP_BOX); box->labelfont(HELVETICA_BOLD_ITALIC); box->labelsize(36); box->labeltype(SHADOW_LABEL); window->end(); window->show(argc, argv); return run(); }

G (LabVIEW)

PUBLIC SUB Main()  Message.Info("Hello, world!")END

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(); } }

GTK+ 2.x (in Euphoria)

include gtk2/wrapper.eInfo(NULL,"Hello","Hell o, world!")

IOC/OCL (in IBM VisualAge for C++)

#include <iframe.hpp>void main(){ IFrameWindow frame("Hello, world!"); frame.showModally()}

Java

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

K

This creates a window labeled "Hello, world!" with a button labeled "Hello, world!".

hello:hello..l:"Hello, world!"hello..c:`button`show$`hello

Microsoft Foundation Classes (in C++)

#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;}

Adobe Flex MXML

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

NSIS

This creates a message box saying "Hello, world!".

OutFile "HelloWorld.exe"Name "Hello, world!"Caption "Hello, world!" Section Hello, world!SectionEnd Function .onInit MessageBox MB_OK "Hello, world!" QuitFunctionEnd

OCaml

Uses lablgtk

let () =   let window = GWindow.window ~title:"Hello" ~border_width:10 () in window#connect#destroy ~callback:GMain.Main.quit; let button = GButton.button ~label:"Hello World" ~packing:window#add () in  button#connect#clicked ~callback:window#destroy;  window#show ();  GMain.Main.main ()

OPL

(On Psion Series 3 and later compatible PDAs.)

PROC guihello:  ALERT("Hello, world!","","Exit")ENDP

or

PROC hello:   dINIT "Window Title"   dTEXT "","Hello, world!"   dBUTTONS "OK",13   DIALOGENDP

Pure Data

Patch as ASCII-art:

[Hello, world!(|[print]

Patch as sourcecode:

#N canvas 0 0 300 300 10;#X msg 100 150 Hello, world!;#X obj 100 200 print;#X connect 0 0 1 0;

Python

Using Tkinter:

from Tkinter import * root = Tk()Label(root, text="Hello, world!").pack() root.mainloop()

Using PyQt:

import sysfrom PyQt4.QtCore import *from PyQt4.QtGui import * app = QApplication(sys.argv)label = QLabel("Hello, World!")label.show()sys.exit(app.exec_())

Using PyGTK:

from gtk import * label = Label("Hello, world!")label.show() window = Window()window.add(label)window.show() main()

Using Curves:

from math import * def f(x): return int(round(96.75 + -21.98*cos(x*1.118) + 13.29*sin(x*1.118) + -8.387*cos(2*x*1.118)\   + 17.94*sin(2*x*1.118) + 1.265*cos(3*x*1.118) + 16.58*sin(3*x*1.118)\   + 3.988*cos(4*x*1.118) + 8.463*sin(4*x*1.118) + 0.3583*cos(5*x*1.118)\   + 5.878*sin(5*x*1.118))) print "".join([chr(f(x)) for x in range(12)])

Qt toolkit (in C++)

 #include <QApplication> #include <QMessageBox>  int main(int argc, char * argv[]) { QApplication app(argc, argv); QMessageBox::information(0, "Qt4", "Hello World!"); }

or

 #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(); }

or

 #include <QApplication> #include <QPushButton> #include <QVBoxLayout>  int main(int argc, char *argv[]) { QApplication app(argc, argv);  QWidget *window = new QWidget; QVBoxLayout *layout = new QVBoxLayout(window); QPushButton *hello = new QPushButton("Hello, world!", window);  //connect the button to quitting hello->connect(hello, SIGNAL(clicked()), &app, SLOT(quit()));  layout->addWidget(hello); layout->setMargin(10); layout->setSpacing(10);  window->show();  return app.exec(); }

Rebol

view layout [text "Hello, world!"]

Robotic (MegaZeux)

* "Hello, world!"end

RPL

(On Hewlett-Packard HP-48G and HP-49G series calculators.)

<< "Hello, world!" MSGBOX >>

RTML

Hello ()TEXT "Hello, world!"

Ruby with WxWidgets

require 'wxruby' class HelloWorldApp < Wx::App def on_init  ourFrame = Wx::Frame.new(nil, -1, "Hello, world!").show  ourDialogBox = Wx::MessageDialog.new(ourFrame, "Hello, world!", "Information:", \ Wx::OK|Wx::ICON_INFORMATION).show_modal endend HelloWorldApp.new.main_loop

Ruby with GTK+

require 'gtk2' Gtk.initwindow = Gtk::Window.newwindow.signal_connect("delete_event") { Gtk.main_quit; false }button = Gtk::Button.new("Hello, world!")button.signal_connect("clicked") { Gtk.main_quit; false }window.add(button)window.show_allGtk.main

Ruby with Tk

require 'tk' window = TkRoot.new { title 'Hello, world!' }button = TkButton.new(window) { text 'Hello, world!' command proc { exit } pack} Tk.mainloop

Ruby

puts "Hello, world!"

Smalltalk

Evaluate in a workspace:

Dialog confirm: 'Hello, world!'

Using the Morphic GUI toolkit of Squeak Smalltalk:

('Hello, world!' asMorph openInWindow) submorphs second color: Color black

Using wxSqueak:

Wx messageBox: 'Hello, world!'

SWT (in Java)

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 (); } }

Tk

label .l -text "Hello, world!"pack .l

and the same in one line

pack [label .l -text "Hello, world!"]

Tcl with Tk

package require Tktk_messageBox -message "Hello, world!"

or

package require Tkpack [button .b -text "Hello, world!" -command exit]

Ubercode

 Ubercode 1 class Hello public function main() code   call Msgbox("Hello", "Hello, world!") end function end class

Uniface

 message "Hello, world!"

Virtools

VBA

Sub Main() MsgBox "Hello, world!"End Sub

Visual Basic .NET 2003/2005

Private Sub Form_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyBase.Load  MessageBox.Show("Hello, world!")  Me.Close() End Sub

Note that the previous example will only work when the code is entered as part of a Form Load Event, such as the one created by default when generating a new project in the Visual Studio programming environment. Equivalently, the following code is roughly equivalent to the traditional Visual Basic 6 code by disabling the Application Framework and setting 'Sub Main' as the entry point for the application:

Public Module MyApplication  Sub Main() MessageBox.Show("Hello, world!")  End SubEnd Class

or using a class;

Public Class MyApplication  Shared Sub Main() MessageBox.Show("Hello, world!")  End SubEnd Class

Visual Prolog (note box)

#include @"pfc\vpi\vpi.ph"goal  vpiCommonDialogs::note("Hello, world!").

Windows API (in C)

This uses the Windows API to create a full window containing the text. Another example below uses the built-in MessageBox function instead.

/* Name: Win32 example Copyright: GLP Author: Ryon S. Hunter( [email protected] ) Date: 20/03/07 17:11 Description: This is an example of what a Win32 hello world looks like.*/#include <windows.h>#define APPTITLE "Win32 - Hello world"BOOL InitInstance(HINSTANCE,int);ATOM MyRegisterClass(HINSTANCE);LRESULT CALLBACK WinProc(HWND,UINT,WPARAM,LPARAM);LRESULT CALLBACK WinProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){   PAINTSTRUCT ps;   COLORREF c = RGB( 0, 0, 0 );   HDC hdc;   RECT rt;   switch(message)   {  case WM_DESTROY: // Exit the window? Ok PostQuitMessage(0);  break;   case WM_PAINT:   GetClientRect( hWnd, &rt );   hdc = BeginPaint( hWnd, &ps );   DrawText( hdc, "Hello world!", sizeof( "Hello world!" ), &rt, DT_CENTER );   EndPaint( hWnd, &ps );  break;   }   return DefWindowProc(hWnd,message,wParam,lParam);}ATOM MyRegisterClass(HINSTANCE hInstance){ WNDCLASSEX wc; wc.cbSize = sizeof( WNDCLASSEX ); wc.style = CS_HREDRAW | CS_VREDRAW; wc.lpfnWndProc = (WNDPROC)WinProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = 0; wc.hIcon = NULL; wc.hCursor = LoadCursor( NULL, IDC_ARROW ); wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); wc.lpszMenuName = NULL; wc.lpszClassName = APPTITLE; wc.hIconSm = NULL; return RegisterClassEx(&wc);}BOOL InitInstance(HINSTANCE hInstance, int nCmdShow){ HWND hWnd; hWnd = CreateWindow( // Create a win32 window APPTITLE, APPTITLE, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 500, 400, NULL, NULL, hInstance, NULL); if(!hWnd){ return FALSE; } ShowWindow( hWnd, nCmdShow ); UpdateWindow( hWnd ); return TRUE;}int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow ){ MSG msg; MyRegisterClass(hInstance); if(!InitInstance( hInstance,nCmdShow) )  return 1; while( GetMessage( &msg, NULL, 0, 0 ) ) {   TranslateMessage( &msg );   DispatchMessage( &msg ); } return msg.wParam;}

XUL

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

Maple

with(Maplets):with(Maplets[Elements]) :maplet := Maplet( "Hello world!" ):Display( maplet );

Document formats

ASCII

The following sequence of characters, expressed in hexadecimal notation (with carriage return and newline characters at end of sequence):

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

The following sequence of characters, expressed as binary numbers (with cr/nl as above, and the same ordering of bytes):

00-07: 01001000 01100101 01101100 01101100 01101111 00101100 00100000 0111011108-0E: 01101111 01110010 01101100 01100100 00100001 00001101 00001010

Page description languages

XHTML 1.1

(Using UTF-8 character set.)

 <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xht ml11.dtd"> <html xmlns="http://www.w3.org/1999/xhtml">  <head>   <title>Hello, world!</title>  </head>  <body>   <p>Hello, world!</p>  </body> </html>

HTML

Simple

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

Informal

The <html> and <body> tags are not necessary for informal testing. Simply write it as text without tags.

Hello, world!

HTML 4.01 Strict (full)

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Strict//EN" "http://www.w3.org/TR/html4/strict.dt d"><html>  <head> <title>Hello, world!</title>  </head>  <body> <p>Hello, world!</p>  </body></html>

The first paragraph of the W3C Recommendation on The global structure of an HTML document also features this example.

HTML 4.01 Strict (smallest)

This is the smallest legal version, leaving out all optional tags

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Strict//EN"><title>Hello, world!</title><p>Hello, world!

HTML 5

<!DOCTYPE html><html>  <head> <meta charset="utf-8"> <title>Hello, World!</title> <link rel="stylesheet" href="style.css">  </head>  <body> <h1>Hello, world!</h1> </body></html>

PDF

%PDF-1.01 0 obj<</Type /Catalog/Pages 3 0 R/Outlines 2 0 R>>endobj2 0 obj<</Type /Outlines/Count 0>>endobj3 0 obj<</Type /Pages/Count 1/Kids [4 0 R]>>endobj4 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>>endobj5 0 obj<< /Length 44 >>streamBT/F1 24 TF100 100 Td (Hello, world!) TjETendstreamendobj6 0 obj[/PDF /Text]endobj7 0 obj<</Type /Font/Subtype /Type1/Name /F1/BaseFont /Helvetica/Encoding /MacRomanEncoding>>endobjxref0 80000000000 65535 f0000000009 00000 n0000000074 00000 n0000000120 00000 n0000000179 00000 n0000000322 00000 n0000000415 00000 n0000000445 00000 ntrailer<</Size 8/Root 1 0 R>>startxref553%%EOF

This is a valid PDF only if the text file has CRLF line endings.

PostScript

% Displays on console.(Hello, world!) =

%!% Displays as page output./Courier findfont24 scalefontsetfont100 100 moveto(Hello, world!) showshowpage

RTF

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

SVG

 <?xml version="1.0" encoding="UTF-8" standalone="no"?> <svg xmlns="http://www.w3.org/2000/svg" width="200" height="100">  <text x="50" y="50">Hello, world!</text> </svg>

TeX

Hello, world!\bye

LaTeX 2ε

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

ConTeXt

 \starttext   Hello, world! \stoptext

Media-based scripting languages

AviSynth

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

(Creates a video with default properties)

Lingo (Macromedia Director scripting language)

on exitFrame me  put "Hello, world!"  end

Outputs the string to the message window if placed in a single movie frame. Alternatively, to display an alert box stating the message you could use

on exitFrame me  alert "Hello, world!"end

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 }}

Esoteric programming languages

This page shows the Hello, world! program in esoteric programming languages — that is, working programming languages that were designed as experiments or jokes and were not intended for serious use.

Alef++

 use java.lang.*; main { System->out->println[ 'Hello, world!' ]; }

Arrow

 ■→→■↓■←■←■↓■� ��→■  /* makes H */ →→■↓■↑↑↑■ /* makes I */

Befunge

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

v v"Hello, world!!"<>  ^> >:#v_@^   .<

0"!dlrow olleH">,:#<_@

BlooP, FlooP

From Eric Raymond's interpreter package (changed to use upper case as in the book).

   DEFINE PROCEDURE ''HELLO-WORLD''[N]:   BLOCK 0: BEGIN   PRINT['Hello, world!'];   BLOCK 0: END.

Brainfuck

 ++++++++++[>+++++++>++++++++++>+++>+<<<<-] >++.>+.+++++++..+++.>++.<<+++++++++++++++. >.+++.------.--------.>+.>.

Chef

   Hello, world! Souffle. Ingredients.   72 g haricot beans   101 eggs   108 g lard   111 cups oil   32 zucchinis   119 ml water   114 g red salmon   100 g dijon mustard   33 potatoes  Method.   Put potatoes into the mixing bowl.   Put dijon mustard into the mixing bowl.   Put lard into the mixing bowl. Put red salmon into the mixing bowl.   Put oil into the mixing bowl.   Put water into the mixing bowl.   Put zucchinis into the mixing bowl.   Put oil into the mixing bowl.   Put lard into the mixing bowl.   Put lard into the mixing bowl.   Put eggs into the mixing bowl.   Put haricot beans into the mixing bowl.   Liquefy contents of the mixing bowl.   Pour contents of the mixing bowl into the baking dish.  Serves 1.

False

"Hello, World!"

The newline before the terminating quote mark is necessary.

HQ9+

   H

INTERCAL programming language

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

LOLCODE

HAI; CAN HAS STDIO?; VISIBLE "Hello, World!";KTHXBYE;

Malbolge programming language

(=<`:9876Z4321UT.-Q+*)M'&%$H"! ~}|Bzy?=|{z]KwZY44Eq0/{mlk**hKs_dG5[m _BA{?-Y;Vb'rR5431M}/.zHGwEDCBA@98\65 43W10/.R,+O<

P programming language

"Hello, world!\n"

Perl

Not really an esoteric language, but this code uses obfuscation:

qq chop lc and print chr ord uc q chop uc and print chr ord q ne sin and print chr ord qw q le q and print chr ord q else and print chr ord q pop and print chr oct oct ord uc qw q bind q and print chr ord q q eq and print chr ord qw q warn q and print chr ord q pop and print chr ord q qr q and print chr ord q else and print chr ord qw q do q and print chr hex length q q semctl setpgrp chop q

SNUSP

   /e+++++++++++++++++++++++++++++.\ ./\/\/\  /+++\!>.+++o.l.+++++++l/  #/?\  $H!\++++++\ +   \comma.------------ .<w++++++++.\ /?\<!\-/   /++++++/ +/\  /.--------o/ \-/!.++++++++++/?\n /=\++++++\ +\!=++++++\ \r+++.l------.d--------.>+.!\-/ \!\/\/\/\/ \++++++++++/

Modular SNUSP:

  /@@@@++++#   #+++@@\ #-----@@@\n$@\H.@/e.+++++++l.l.+++o.& gt;>++++.< .<@/w.@\o.+++r.++@\l.@\d.>+.@/. #  \@@@@=>++++>+++++<<@+++++ #   #---@@/!=========/!==/

Spoon (programming language)

0101111111110010001111111111010000001 1011001010010111111100100011111101000 0001101110010101111111001010001010111 0010100101111111111100100011000000000 0000000000100000011011000001010000000 0000000000000000000000000000000010100101111111111100100011111110100000011011001010010111111001000111111010000001101100101011100101000000000000000000000101000000000000000000000000000101001011111111111001000110000000000000000000100000011011000001010

Super NAND Time!!

12 (32 35 37 38 42)13 (35 37 38 39 43)14 ((31 36 39 42 43))15 (31 33 34 35 38 40 43)16 (37 39)17 ((31 43))18 ((36 42 43))20 ((42(43)))21 4431 ((31)(44))32 (32(31))33 (33(32))34 (34(33))35 (35(34))36 (36(35))37 (37(36))38 (38(37))39 (39(38))40 (40(39))41 (41(40))42 (42(41))43 (43(42))44 1

Taxi programming language

"Hello, World!" is waiting at the Writer's Depot.Go to Writer's Depot: west 1st left, 2nd right, 1st left, 2nd left.Pickup a passenger going to the Post Office.Go to the Post Office: north 1st right, 2nd right, 1st left.Go to the Taxi Garage: north 1st right, 1st left, 1st right.

T programming language

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

This=That

x=Hello,world!x=print

Unlambda programming language

  `r```````````.H.e.l.l.o. .w.o.r.l.di

Var'aq programming language

Note: actually prints "What do you want, universe?" in Klingon.

 ~ nuqneH { ~ 'u' ~ nuqneH disp disp } name   nuqneH

Whitespace

Note that whitespace has been highlighted (Space, Tab)

                                                                                                                        empty-line empty-line  empty-line       empty-line  empty-line    empty-lineempty-line/EOF

XS programming language

<print>Hello, world!</print>

DUNNBOL1

A code language that draws in binary on a braille plotter (note that this is just the word HELLO).

BGN GRPLOT BINDRAWPLOT000000000000000000000000000000000000000000000000000000000011100111001111111001110000000011100000000001111100000000010000100001000010001000000000010000000000100000100000000100001000010000000010000000000100000000001000001000000001111110000111100000100000000001000000000010000010000000010000100001000000001000000000010000000000100000100000000100001000010000100010000000000100000000001000001000000011100111001111111001111111100011111111000001111100000000000000000000000000000000000000000000000000000000000000ENDDRAWEND