Jump to content

Computer Programming/Hello world

From Wikibooks, open books for an open world

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" does not run, one must not try to develop complex programs before fixing the issues with the installation.

For even more languages have a look at the Hello World Collection.

4DOS batch

[edit | edit source]

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

 @echo Hello, world!

Ingres 4GL

[edit | edit source]
message "Hello, world!" with style = popup;

ABAP/4 - SAP AG

[edit | edit source]
 REPORT ZHELLO.
 START-OF-SELECTION.
   WRITE "Hello, world!".

ABAP Objects (NetWeaver 7)

[edit | edit source]

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( ).
WRITE "Hello, world!" 

ActionScript

[edit | edit source]

ActionScript 1.0 and 2.0

[edit | edit source]

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

[edit | edit source]
package
{
    public class HelloWorld
    {
        public function HelloWorld()
        {
            trace("Hello, world!");
        }
    }
}
with Ada.Text_IO;

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

ALGOL 68

[edit | edit source]

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

[edit | edit source]
PROC main()
   WriteF('Hello, world!');
ENDPROC

AMX NetLinx

[edit | edit source]

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

program_name = 'Hello'
define_start
send_string 0,'Hello World!'
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE project>
<project default="helloworld">
	<target name="helloworld">
		<echo message="Hello, World!" />
	</target>
</project>
    RHWΔPGM 
[1] R'HELLO WORLD!'
    
  • 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ΔPGM
Hello, 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

[edit | edit source]
return "Hello, world!"

or:

display dialog "Hello, world!"
<% Response.Write("Hello, world!") %>
or simply:
<%= "Hello, world!" %>

ASP.NET

[edit | edit source]
// in the page behind using C#
protected void Page_Load(object sender, EventArgs e)
{
 Response.Write("Hello, world!");
}
' in the page behind using VB.NET
Protected 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

[edit | edit source]

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

[edit | edit source]

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

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

[edit | edit source]
 bdos    equ    0005H    ; BDOS entry point
 start:  mvi    c,9      ; BDOS function: output string
         lxi    d,msg$   ; address of msg
         call   bdos
         ret             ; return to CCP
 
 msg$:   db    'Hello, world!$'
 end     start
[edit | edit source]
  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          AND A        ; 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 printed
 100          JR LOOP
 110          RET
 120 MSG      DEFM "Hello, world!"
 130          DEFB 13      ; carriage return
 140          DEFB 0       ; null terminator

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

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

Accumulator/Index microcoded machine: Data General Nova, RDOS

[edit | edit source]

See the example section of the Nova article.

Expanded accumulator machine: Intel x86, DOS, TASM

[edit | edit source]
MODEL   SMALL
IDEAL
STACK   100H
 
DATASEG
        MSG DB 'Hello, world!', 13, '$'
 
CODESEG
Start:
        MOV AX, @data
        MOV DS, AX
        MOV DX, OFFSET MSG
        MOV AH, 09H      ; DOS: output ASCII$
        INT 21H
        MOV AX, 4C00H
        INT 21H
END Start

ASSEMBLER x86 (DOS, MASM)

[edit | edit source]
.MODEL Small
.STACK 100h
.DATA
   db msg 'Hello, world!$'
.CODE
start:
   mov ah, 09h
   lea dx, msg ; or mov dx, offset msg
   int 21h
   mov ax,4C00h
   int 21h
end start

ASSEMBLER x86 (DOS, FASM)

[edit | edit source]
; 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 DOS
xhello db 'Hello world !!!$'

Expanded accumulator machine: Intel x86, Microsoft Windows, FASM

[edit | edit source]

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

format PE GUI 
entry 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 required for 32-bit Windows NT executables, recommended for DOS-based Windows, required for x64), no heap - Not a beginners example but only 1024 instead of 3072 bytes:

format PE GUI 4.0
heap 0
entry start
include 'win32a.inc'

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
section '.reloc' fixups data readable discardable

Expanded accumulator machine: Intel x86, Linux, FASM

[edit | edit source]
format ELF executable
entry _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

[edit | edit source]
.data
msg:
    .ascii     "Hello, world!\n"
    len = . - msg
.text
    .global _start
_start:
    movl $len,�x
    movl $msg,�x
    movl $1,�x
    movl $4,�x
    int $0x80
    movl $0,�x
    movl $1,�x
    int $0x80

Expanded accumulator machine: Intel x86, Linux, NASM

[edit | edit source]
    section .data
msg     db      'Hello, world!',0xA
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

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

[edit | edit source]
extern printf ; Request symbol "printf".
global main   ; Declare symbol "main".
 
section .data
  str: DB "Hello World!", 0x0A, 0x00
 
section .text
main:
  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

[edit | edit source]
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

General-purpose fictional computer: MMIX, MMIXAL

[edit | edit source]
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

[edit | edit source]

RT-11, MACRO-11

[edit | edit source]
         .MCALL  .REGDEF,.TTYOUT,.EXIT
         .REGDEF
 
 HELLO:  MOV    #MSG,R1
         MOVB   (R1) ,R0
         BEQ    EXIT
 LOOP:  .TTYOUT
         BR    LOOP
EXIT:
        .EXIT
 
 MSG:   .ASCIZ  /Hello, world!/
        .END    HELLO

Variant for Elektronika BK using BIOS function, MICRO-11

[edit | edit source]
         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
         HALT
 
 TXT:    .ASCIZ  /Hello, world!/
         .END

CISC Amiga (Workbench 2.0): Motorola 68000

[edit | edit source]
        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
        jmp      _LVOCloseLibrary(a6)
 
dosname     dc.b 'dos.library',0
hellostr    dc.b 'Hello, world!',0

CISC Atari: Motorola 68000

[edit | edit source]
;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

[edit | edit source]
        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

[edit | edit source]
         .title    hello
 
         .psect    data, wrt, noexe
 
 chan:   .blkw     1
 iosb:   .blkq     1
 term:   .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 system
 end:    ret
 
        .end       hello

Mainframe: IBM z/Architecture series using BAL

[edit | edit source]
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

[edit | edit source]
 .program         
          ADR R0, message
          SWI "OS_Write0"
          SWI "OS_Exit"
 .message         
          EQUS "Hello, world!"
          EQUB 0
          ALIGN

or the even smaller version (from qUE);

         SWI "OS_WriteS":EQUS "Hello, world!":EQUB0:ALIGN:MOV PC,R14

RISC processor: MIPS architecture

[edit | edit source]
          .data
 msg:     .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

[edit | edit source]
 .data
 msg:
     .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

[edit | edit source]
        SYSTEM   BPM
 START  M:PRINT (MESS,HW)
        M:EXIT
 HW     TEXTC    'HELLO WORLD'
        END      START

AutoHotkey

[edit | edit source]
MsgBox, Hello, world!

(The comma after the command name is optional.)

AutoIt

[edit | edit source]
MsgBox(0,'','Hello, world!')

Avenue (scripting language for ArcView GIS)

[edit | edit source]
MsgBox("Hello, world!","aTitle")
BEGIN { print "Hello, world!" }

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

[edit | edit source]

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

3GL Format

[edit | edit source]
function main()
{
    message("Hello, world!")
}

4GL Format

[edit | edit source]
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

[edit | edit source]
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

[edit | edit source]

General

[edit | edit source]

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

[edit | edit source]
Print "Hello, world!"
WaitKey

DarkBASIC

[edit | edit source]
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

[edit | edit source]
PRINT "Hello World"
SLEEP
END

or

PRINT "Hello World"

or

? "Hello World"

or

'without a newline
? "Hello World";

CoolBasic

[edit | edit source]
AddText "Hello, world!"
DrawScreen
WaitKey

GW-BASIC

[edit | edit source]
10 PRINT "Hello, World!"
20 END

Liberty BASIC

[edit | edit source]

To write to the main window:

print "Hello, world"

Or drawn in a graphics window:

nomainwin
open "Hello, world!" for graphics as #main
print #main, "place 50 50"
print #main, "\Hello, world!"
print #main, "flush"
wait

Microsoft Small Basic

[edit | edit source]
TextWindow.WriteLine("Hello, world!")

PBASIC

[edit | edit source]
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

[edit | edit source]
 sub main
     print "Hello, world!"
 end sub

PureBasic

[edit | edit source]
 OpenConsole()
 PrintN("Hello, world!")
 Input()

or

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

or

Debug "Hello, World"
PRINT "Hello, World"                                                                                                                                                                                                     END

Same for QBasic

TI-BASIC

[edit | edit source]

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" menu, "Probability" menu, or "Math" menu (as factorial notation).

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

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

Visual Basic

[edit | edit source]
Public Sub Main()
    Debug.Print "Hello, world!"
End Sub

or

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

or

Private Sub Form_Activate()
    Print "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

[edit | edit source]
Module HelloWorldApp
  Sub Main()
     System.Console.WriteLine("Hello, world!")
  End Sub
End Module

PICK/BASIC, DATA/BASIC, MV/BASIC

[edit | edit source]

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)

[edit | edit source]
@echo Hello World!

or

@echo off
set hellostring=Hello World!
echo %hellostring%

or

@echo off
echo Hello World!
pause
exit

or

@echo Hello World!
pause
exit

As a CGI file

[edit | edit source]
@echo off
echo Content-type: text/plain >> sample.cgi
echo. >> sample.cgi
echo. >> sample.cgi
echo Hello, world! >> sample.cgi
"Hello, world!"

or, with the newline

 print "Hello, world!\n"
GET "LIBHDR"

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

BITGGAL AgileDog

[edit | edit source]
T 
 1 "Hello, World"
 0

BITGGAL Jihwaja

[edit | edit source]
J( 1 TM 5 ZV 3 "Hello, world" )

BLISS

[edit | edit source]
%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

BlitzMax

[edit | edit source]
 SuperStrict
 Graphics 640, 480, 0, 60
 
 Local running:Int = 1
 While running
 	Cls
 	DrawText "Hello World!", 1, 1
 	Flip
 
 	If GetChar()
 		running = 0
 	EndIf
 Wend
 
 End

See also GUI section.

print "Hello, world!"

Burning Sand 2

[edit | edit source]
WRITE ELEMENT:Earth 210 230 40 CENTER TEXT "Hello World!"
#include <stdio.h>

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

ANSI C

[edit | edit source]
#include <stdio.h>

int main(void) {
    printf("Hello, World!\n");

    return 0;
}

Caché Server Pages (CSP)

[edit | edit source]
 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

[edit | edit source]

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

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

C/AL - MBS Navision

[edit | edit source]
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

[edit | edit source]

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

"Hello, world!"

or

Locate 1,1,"Hello, world!"
 call echo("Hello, world!")

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

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

Chuck

[edit | edit source]
 <<<"Hello World">>>;

Chrome

[edit | edit source]
namespace HelloWorld;
 
interface
 
type
  HelloClass = class
  public
    class method Main; 
  end;
 
implementation
 
class method HelloClass.Main;
begin
  System.Console.WriteLine('Hello, world!');
end;
 
end.
.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)

[edit | edit source]
<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 Function
End Class
]]>
	</Code>
</Script>

Clean

[edit | edit source]
 module hello
 
 Start = "Hello, world!"

Clipper

[edit | edit source]
 ? "Hello, world!"

or

 @1,1 say "Hello, world!"

or

 Qout("Hello, world")

CLIST

[edit | edit source]
PROC 0
WRITE Hello, world!

Clojure

[edit | edit source]
(println "Hello, world!")
start_up = proc ()
    po: stream := stream$primary_output ()
    stream$putl (po, "Hello, world!")
    end start_up

COBOL

[edit | edit source]
      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.

CoffeeScript

[edit | edit source]

CoffeeScript is a language that compiles into JavaScript. Like JavaScript, it does not have native (built in) input or output routines, instead relying on the facilities provided by its host environment.

Using an alert that uses a standard Web browser's window object (window.alert)

alert 'Hello, world!'

or, from Firebug, Apple Safari, or Google Chrome debug console, or Node.js console

console.log 'Hello, world!'

ColdFusion (CFML)

[edit | edit source]
<cfoutput>Hello, world!</cfoutput>

or

Hello, world!

COMAL

[edit | edit source]
 PRINT "Hello, world!"

Common Lisp

[edit | edit source]
(princ "Hello, world!")
Function | Main  
WriteLine | "Hello, world"
End | Main

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

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

C /CLI

[edit | edit source]
int main() {
   System::Console::WriteLine("Hello, world!");
   return 0;
}

C , Managed (.NET)

[edit | edit source]
#using <mscorlib.dll>

using namespace System;

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

See also GUI section.

using System;

internal static class HelloWorld
{
    private static void Main()
    {
        Console.WriteLine("Hello, world!");
    }
}
 import std.stdio ;
  
 void main () {
     writefln("Hello, world!");
 }

Tango version:

 import tango.io.Stdout;

 void main() {
     Stdout ("Hello, world!").newline;
 }
main() {
  print('Hello, world!');
}

Or,

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

DC, an arbitrary precision calculator

[edit | edit source]
[Hello, world!]p

or

1468369091346906859060166438166794P

In the second example, DC stores the decimal number as a sequence of bits, and then the "P" tells DC to interpret those bits as a string and print it.

DCL batch

[edit | edit source]
$ write sys$output "Hello, world!"

Delphi

[edit | edit source]
{$APPTYPE CONSOLE}
begin
  Write('Hello, world!');
end.
PROGRAM hello;
BEGIN
    write(0, 0, 0, 0, "Hello, world!");
    LOOP
        FRAME;
    END
END
this::operator()
{
 import system.cstdio;
 puts("Hello, world!");
}

Dream Maker

[edit | edit source]
mob
    Login()
        ..()
        world << "Hello, world!"

Dylan

[edit | edit source]
 module: hello
 
 format-out("Hello, world!\n");

EAScripting

[edit | edit source]
set disp to "Hello, world!"
set dispto to item unit 5 //5 = default screen
release disp into dispto.

This would be a pure system call

import system ea.helloworld
wait

Ed and Ex (Ed extended)

[edit | edit source]
a
Hello, world!!
.
p

Ecstasy (xtclang)

[edit | edit source]
module HelloWorld
    {
    void run()
        {
        @Inject Console console;
        console.print("Hello World!");
        }
    }

Eiffel

[edit | edit source]
class HELLO_WORLD
 
create make
feature
    make is
    do
        io.put_string("Hello, world!%N")
    end -- make
end -- class HELLO_WORLD

Elixir

[edit | edit source]
IO.puts "Hello, world!"
import Html exposing (text)

main =
  text "Hello, World!"

Erlang

[edit | edit source]

See also GUI section.

-module(hello).

-export([hello/0]).

hello() -> io:format("Hello, world!~n").

Euphoria

[edit | edit source]
puts(1, "Hello, world!")

Factor

[edit | edit source]
 "Hello, world!" print

or gui version

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

Falcon

[edit | edit source]
printl( "Hello world" )

Ferite

[edit | edit source]
uses "console";

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

filePro

[edit | edit source]
 @once:
   mesgbox "Hello, world!" ; exit

Fjölnir

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

FOCAL

[edit | edit source]
type "Hello, world!",!

or

t "Hello, world!",!

Focus

[edit | edit source]
-TYPE Hello, world!

Forte TOOL

[edit | edit source]
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

[edit | edit source]
 : 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

[edit | edit source]

Fortran 77

[edit | edit source]
00    program hello
      write(*,*) 'Hello World!'
      stop
      end

Fortran 90/95

[edit | edit source]
program hello
    write(*,*) 'Hello, World!'
end program hello
printfn "Hello, world!"
?((pp "Hello, world!"))     

or

pp "Hello, world!"

Frink

[edit | edit source]
println["Hello, world!"]

Gambas

[edit | edit source]

See also GUI section.

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

GEMBase 4GL

[edit | edit source]
procedure_form hello
  begin_block world
      print "Hello, world!"
  end_block
end_form

GeneXus

[edit | edit source]
Msg("Hello World")


GML (Game Maker Language)

[edit | edit source]

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)

[edit | edit source]
package main

import "fmt"

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

GraalScript

[edit | edit source]

GraalScript 1

[edit | edit source]
 if (created) {
   echo Hello, world!;
 }

GraalScript 2

[edit | edit source]
 function onCreated() {
   echo("Hello, world!");
 }

Groovy

[edit | edit source]
println "Hello, world!"

Harbour

[edit | edit source]
? "Hello, world!"

or

@1,1 say "Hello, world!"

or

Qout("Hello, world")

Haskell

[edit | edit source]
main = putStrLn "Hello, world!"
class HelloWorldApp
{
    static function main()
    {
        trace("Hello, world!");
    }
}

Heron

[edit | edit source]
program HelloWorld;
functions {
  _main() {
    print_string("Hello, world!");
  }
}
end

HP 33s

[edit | edit source]

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

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

[edit | edit source]

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

01 LBLTHELLO

02 THello, world!

03 PROMPT

HyperTalk (Apple HyperCard's scripting programming language)

[edit | edit source]
 put "Hello, world!"

or

 Answer "Hello, world!"
procedure main()
    write("Hello, world!")
end
 print,"Hello, world!"
"Hello, world!" println

or

writeln("Hello, world!")

Inform

[edit | edit source]

Inform 5/6

[edit | edit source]
 [ Main;
   "Hello, world!";
 ];

Inform 7

[edit | edit source]
 Hello World is a room.  The printed name is "Hello, world!"

Iptscrae

[edit | edit source]
ON ENTER {
    "Hello, " "world!" & SAY
}
'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
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 = "!"

See also GUI section.

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

Java byte-code

[edit | edit source]

(disassembler output of javap -c HelloWorld)

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

Java byte-code Jasmin Syntax

[edit | edit source]
.class HelloWorld
.super java/lang/Object
.method public static main([Ljava/lang/String;)V
  .limit stack 2
  getstatic java/lang/System/out Ljava/io/PrintStream;
  ldc "Hello, world!"
  invokevirtual java/io/PrintStream/println(Ljava/lang/String;)V
  return
.end method

JavaFX Script

[edit | edit source]

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

[edit | edit source]

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.write('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!');

JCL (mainframe Job Control Language)

[edit | edit source]
//HERIB    JOB  ,'HERIBERT OTTEN',PRTY=12
//* HELLO WORLD FOR MVS            
//HALLO    EXEC PGM=IEBGENER       
//SYSIN    DD DUMMY                
//SYSPRINT DD SYSOUT=*             
//SYSUT2   DD SYSOUT=T             
//SYSUT1   DD *                    
HELLO WORLD!                       
/*                                 
//
"Hello, world!\n" putchars .
 <%@ page contentType="text/html;charset=WINDOWS-1252"%>
 <HTML>
    <BODY>
         <% out.println(" Hello, world!"); %>
    </BODY>
 </HTML>

or just

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

or literally

 Hello, world!

Julia

[edit | edit source]
 println("Hello, world!")
 `0:"Hello, world!\n"
`plain
'Hello World!' #echo #

Kotlin

[edit | edit source]
fun main() {
   println("Hello World!")
}


Kogut

[edit | edit source]
WriteLine "Hello, world!"

KPL (Kids Programming Language)

[edit | edit source]
Program HelloWorld
   Method Main()
      ShowConsole()
      ConsoleWriteLine("Hello, world!")
   End Method
End Program

Lasso

[edit | edit source]
 Output: 'Hello, world!';

or

 Output('Hello, world!');

or simply

'Hello, world!';

Lexico Mobile (in Spanish)

[edit | edit source]
tarea muestre "Hola mundo !"

or

clase Saludo derivada_de Form
publicos
mensajes
Saludo copie "Hola mundo !" en saludo.Text

Linden Scripting Language

[edit | edit source]

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

[edit | edit source]
Livre : HelloWorld
 Paragraphe : Affichage
 Actions :
   "Hello, World !" !

Lisaac

[edit | edit source]
Section Header
    name := HELLO_WORLD_PROGRAM;

Section Public
  - main <-
  (
    "Hello world!\n".print;
  );

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

Common Lisp

[edit | edit source]
(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

[edit | edit source]
(display "Hello, world!\n")

Clojure

[edit | edit source]
(println "Hello, world!")

Emacs Lisp

[edit | edit source]
(print "Hello, world!")

or:

(message "Hello, world!")

AutoLisp

[edit | edit source]
(print "Hello, world!")

XLISP

[edit | edit source]
(print "Hello, world!")
(prn "Hello, world!")
(out "Hello, world!")
print [Hello, world!]

or

pr [Hello, world!]

In MSWLogo only

messagebox [Hi] [Hello, world!]
  void create()
  {
      write("Hello, world!\n");
  }
io.write("Hello, world!\n")

or

return "Hello, World!"

or

print("Hello, world")

LuaDEV (PSP and Wii)

[edit | edit source]
 screen.print(10,10,"Hello, world!")

M (MUMPS)

[edit | edit source]
W "Hello, world!"

Macsyma, Maxima

[edit | edit source]
 print("Hello, world!")$

Maple

[edit | edit source]
print("Hello, world!");

Mathematica

[edit | edit source]
 Print["Hello, world!"]

or simply:

"Hello, world!"

MATLAB / GNU Octave

[edit | edit source]
disp('Hello, world!')

or

fprintf('Hello, world!\n')

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

[edit | edit source]
fmod HELLOWORLD is
protecting STRING .
  op helloworld : -> String .
  eq helloworld = "Hello, world!" .
endfm
red helloworld .
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

[edit | edit source]
print( "Hello, world!\n" );

Mesham

[edit | edit source]
var x:String::allocated[on[0]];
x:="Hello World";  // allocated on process 0 only
proc 1 {
   // This is displayed by process 1, auto communication done to achieve this
   print[x];
}
Hello, world!

Microbit

[edit | edit source]

mIRC Script

[edit | edit source]

aliases

[edit | edit source]
helloworld echo Hello, world!

remote

[edit | edit source]
alias helloworld echo Hello, world!

popups

[edit | edit source]
Hello World:echo Hello, world!

command line

[edit | edit source]
echo Hello, world!

Model 204

[edit | edit source]
BEGIN
PRINT 'Hello, world!'
END

Modula-2

[edit | edit source]
MODULE Hello;

FROM InOut IMPORT WriteLn, WriteString;

BEGIN
   WriteString ("Hello, world!");
   WriteLn
END Hello.

Monkey

[edit | edit source]
 Strict
 
 Function Main:Int()
  Print "Hello World!"
  
  Return 0
 End

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

[edit | edit source]
"Hello, World!"
$
#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

[edit | edit source]

Script

[edit | edit source]
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

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

Command WoI

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

MS-DOS batch

[edit | edit source]

(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 off
cls
echo Hello, world!
: main
  me @ "Hello, world!" notify
;

Natural

[edit | edit source]
WRITE 'Hello, world!'
END

or

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

Nemerle

[edit | edit source]

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!");
    }
 }
echo "Hello, world!"

or

echo("Hello, world!")

NXT 2.1 (the Lego Robot program)

[edit | edit source]

Oberon

[edit | edit source]

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.Ln
END Hello.
system.console.write_line ( "Hello, world!" )

ObjectGears

[edit | edit source]

Message to the user in the form:

OGForm.SetInfo('Hello world!');

Entry into the log:

OG.Log.Write('Hello world!');

Objective C

[edit | edit source]

Procedural C Version

[edit | edit source]
#import <stdio.h>

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

Object-Oriented C Version

[edit | edit source]
#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

[edit | edit source]
#import <Foundation/Foundation.h>

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

OCaml

[edit | edit source]
print_endline "Hello, world!" ;;

occam

[edit | edit source]
#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

[edit | edit source]
-- in a popup window
request "Hello world"

See also GUI section.

PROC hello:
  PRINT "Hello, world!"
ENDP
 (object-class request
          ^action)
 
 (startup
    (strategy MEA)
    (make request ^action hello)
 )
 
 (rule hello
    (request ^action hello)
    (write |Hello, world!| (crlf))
 )

OPS83

[edit | edit source]
module hello (main)
{  procedure main( )
   {
      write() |Hello, world!|, '\n';
   };
};
{Browse 'Hello, world!'}

Parrot assembly language

[edit | edit source]
 print "Hello, world!\n"
 end

Parrot intermediate representation

[edit | edit source]
 .sub hello :main
   print "Hello, world!!\n"
 .end

Pascal

[edit | edit source]
begin
   write('Hello, world!');
end.
main() {
    print("Hello, World!");
}

or

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

As PL file

[edit | edit source]
 print "Hello, world!\n";

(the semicolon is optional)

or

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

As CGI file

[edit | edit source]
#!/usr/local/bin/perl
print "Content-type: text/html\n\n";
print "<H1>Hello World!</H1>";
puts(1, "Hello, world!")

PHP is a templating language and will echo any text not within PHP tags directly, so the simplest form is:

Hello, world!

Using actual PHP statements, it can be written:

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

or use short-hand echoing, syntaxed as such:

<? echo "Hello, world!"?>

this will also work:

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

PILOT

[edit | edit source]
T:Hello, world!

PL/SQL

[edit | edit source]
set serveroutput on size 1000000;  -- this is a SQL*Plus command to enable the output buffer
begin
    dbms_output.put_line('Hello, world!'); 
end;
Test: proc options(main);
  put list('Hello, world!');
end Test;

PostScript

[edit | edit source]

See also page description language section.

 (Hello, world!\n) print

PowerShell

[edit | edit source]
"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!")

Processing

[edit | edit source]
println("Hello, world!");

Progress 4GL

[edit | edit source]
 display "Hello, world!".

Prolog

[edit | edit source]
:- write('Hello, world!'),nl.

Pure Data

[edit | edit source]
#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

[edit | edit source]

As a script/module

[edit | edit source]

Python 2 and earlier

[edit | edit source]
print "Hello, world!"

Python 3

[edit | edit source]
print("Hello, world!")

This also works on Python 2.4 or later, but in an unintuitive way. In Python 3, it calls the print function with the string "Hello, world!". In Python 2, it executes the print statement with the expression ("Hello, world!"), which evaluates to the string "Hello, world!".

Any Python version

[edit | edit source]
import sys
sys.stdout.write("Hello, world!\n")

In Python 2.6 or later:

from __future__ import print_function
print("Hello, world!")

Two easter eggs

[edit | edit source]
import __hello__
import __phello__

Using Curves

[edit | edit source]
from math import cos, sin
 
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)]))

In the REPL

[edit | edit source]

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

'Hello, world!'

As CGI file

[edit | edit source]
#!/usr/local/bin/python
print("Content-type: text/html\n\n")
print("Hello World!")

Flask

[edit | edit source]

As Python's Flask web microframework

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

app.run()
print('Hello, world!')
"Hello, world!".say

or

say "Hello, world!";

or

print "Hello, world!\n";

Rebol

[edit | edit source]

See also GUI section.

print "Hello, world!"

See also GUI section.

print "Hello, world!"

Redcode

[edit | edit source]
 ; Should work with any MARS >= ICWS-86
 ; with 128x64 gfx core
 Start 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

[edit | edit source]
$ENTRY GO{=<Prout 'Hello, world!'>;}

Revolution

[edit | edit source]

(This works the same for Transcript or xTalk)

Printed in the message box

[edit | edit source]
put "Hello, World!" 

Shown within a dialog box

[edit | edit source]
answer "Hello, world!" 

Printed on the main window interface

[edit | edit source]
create field "myField"
set the text of field "myField" to "Hello, world!"

As CGI file

[edit | edit source]
#!revolution 

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

REXX, ARexx, NetRexx, and Object REXX

[edit | edit source]
 /* a starting comment is needed in mainframe versions */
 say "Hello, world!"
 see "hello world!"

Free-Form Syntax

[edit | edit source]
/FREE

    DSPLY 'Hello, world!';

    *InLR = *On;

/END-FREE 

Traditional Syntax

[edit | edit source]

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

[edit | edit source]

Message Window

[edit | edit source]

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

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

On Screen Text

[edit | edit source]

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

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

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

[edit | edit source]
_name   Hello~World!
pause   Hello~World!
exit
_end

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
fn main() {
    println!("Hello, world!");
}

S (and R)

[edit | edit source]
print("Hello, world")

or

message("Hello, world")

S-Lang

[edit | edit source]
message("Hello, world!");
%put Hello, world!;

Sather

[edit | edit source]
class HELLO_WORLD is
  main is 
   #OUT "Hello, world!\n"; 
  end; 
end;

Scala

[edit | edit source]
object HelloWorld extends App {
  println("Hello, world!")
}

App was introduced since Scala 2.1, and Application was deprecated since Scala 2.9.0. Use Application instead of App for versions below 2.1.

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

Scheme

[edit | edit source]
(display "Hello, World!") (newline)

Scratch

[edit | edit source]

(Note: requires at least one line of input)

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

Seed7

[edit | edit source]
$ include "seed7_05.s7i";

const proc: main is func
  begin
    writeln("Hello, world");
  end func;
'Hello, world!' print.

sense script

[edit | edit source]
out('Hello, world!');

ShadowScript

[edit | edit source]
'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/

Simula

[edit | edit source]
BEGIN
    OutText("Hello, world!");
    OutImage;
END

Smalltalk

[edit | edit source]
Transcript show: 'Hello, world!'

alternative:

StdoutStream nextPutLine: 'Hello, world'
print "Hello, world!\n";

SNOBOL

[edit | edit source]
     OUTPUT = "Hello, world!"
 END
class Hello {
  static public main: args {
    Console << "Hello, world!\n";
  }
}

SPARK

[edit | edit source]
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;

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_000
OBJ
    console : "FullDuplexSerial"
PUB start
    console.start(31, 30, 0, 115_200)
    console.str(string("Hello, world!", 13))

SPITBOL

[edit | edit source]
     OUTPUT = "Hello, world!"
 END

SPSS Syntax

[edit | edit source]
ECHO "Hello, world!".
1.0
print Hello, World!
end

Standard ML

[edit | edit source]
print "Hello, world!\n";
 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

[edit | edit source]
RACINE: HELLO_WORLD.

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

Stata

[edit | edit source]

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

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

Or, interactively at the command line:

di "Hello, world!"

SuperCollider

[edit | edit source]
 "Hello, world!".postln;

or, for interactive prompt,

"Hello, world!"

Supernova

[edit | edit source]
I want window and the window title is hello world.

Swift

[edit | edit source]
 println("Hello, world!") // Swift 1.x

 print("Hello, world!")   // Swift 2.x
#OUTPUT Hello, world!

Tcl (Tool command language)

[edit | edit source]

See also GUI section.

puts "Hello, world!"

Template Toolkit

[edit | edit source]
[% GET "Hola mundo!"; %]

Or the English version:

[% GET "Hello world!"; %]

Thyme

[edit | edit source]
 print ("Hello, world!")

TOM (rewriting language)

[edit | edit source]
 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"); }
    }
  }
Declare @Output varchar(16)
Set @Output='Hello, world!'
Select 'Output' = @Output

or, simpler variations:

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

TTCN-3

[edit | edit source]
module hello_world {
  control {
    log("Hello, world!");
  }
}

Turing

[edit | edit source]
put "Hello world!"

UNIX-style shell

[edit | edit source]
 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
using GLib;

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

Verilog

[edit | edit source]
module main();
       initial begin
              #0 $display("Hello, world!!");
              #1 $finish;
       end
endmodule

or (a little more complicated)

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

entity Hello is
end Hello;

architecture Hello_Arch of Hello is
begin
       p : process
       variable l:line;
       begin
               write(l, String'("Hello, world!"));
               writeline(output, l);
               wait;
       end process;
end Hello_Arch;

Visual Basic Script

[edit | edit source]
WScript.Echo "Hello, world!"

OR as a VBscript file

MsgBox "Hello, world!"

Visual Prolog

[edit | edit source]
#include @"pfc\console\console.ph"

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

VRML (Virtual Reality Modeling Language)

[edit | edit source]
#X3D V3.3 utf8
Shape {
  geometry Text {
    string [ "hello, world" ]
  }
}

Web Assembly

[edit | edit source]
 (module
   (type $type0 (func (result i32)))
   (table 0 anyfunc)
   (memory 1)
   (export "memory" memory)
   (export "hello" $func0)
   (func $func0 (result i32)
     i32.const 16
   )
   (data (i32.const 16)
     "Hello World\00"
   )
 )
sub:main
load:mscorlib.dll
push:Hello, World!
invoke:mscorlib.dll:System.Console:Write:1
endsub

X3D (Extensible 3D)

[edit | edit source]
<X3D profile='Immersive' version='3.3'>
  <Scene>
    <Shape>
      <Text string='"hello, world"'/>
    </Shape>
  </Scene>
</X3D>

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 buffering
out 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 console
void 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;
}
   use XL.UI.CONSOLE
   WriteLn "Hello, world!"

or

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

XMLmosaic

[edit | edit source]
<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

[edit | edit source]
write, "Hello, world!";

Note: The semicolon is optional.

Zdzich

[edit | edit source]

Programming language with commands in Polish. Webpage

pisz Hello World!
koniec

Graphical user interfaces (GUIs)

[edit | edit source]

ActionScript (Adobe Flash)

[edit | edit source]
this.createTextField("hello_txt",0,10,10,100,20);
this.hello_txt.text="Hello, world!";

AppleScript

[edit | edit source]
display dialog "Hello, world!" buttons {"OK"} default button 1
import System.Drawing
import System.Windows.Forms
f = Form()
f.Controls.Add(Label(Text: "Hello, world!", Location: Point(40,30)))
f.Controls.Add(Button(Text: "Ok", Location: Point(50, 55), Click: {Application.Exit()}))
Application.Run(f)

Functional equivalent of C# program below.

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

[edit | edit source]

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
    MAP
HelloProcedure  PROCEDURE()
    END

    CODE
    HelloProcedure()
    RETURN

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

[edit | edit source]
#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 3.0, 4.0 applet}
{curl-file-attributes character-encoding = "utf-8"}

Hello, world!

Delphi, Kylix

[edit | edit source]
program Hello_World;
uses    
  QDialogs;

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

or

program Hello_World;
uses    
  QDialogs;

begin
  MessageDlg ('Hello, world!', mtInformation, [mbOk], 0);
end.

Erlang

[edit | edit source]
-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

[edit | edit source]

MS-Windows only - basic.

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

MS-Windows only - using Win32Lib library

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

Using WindowsForms, at the F# interactive prompt:

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

FLTK2 (in C )

[edit | edit source]
#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)

[edit | edit source]
PUBLIC SUB Main()
  Message.Info("Hello, world!")
END

Gtk# (in C#)

[edit | edit source]
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)

[edit | edit source]
include gtk2/wrapper.e

Info(NULL,"Hello","Hello, world!")

IOC/OCL (in IBM VisualAge for C )

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

Swing

[edit | edit source]
import javax.swing.*;

class HelloWorld {

    public static void main(final String[] args) {
        JFrame frame = new JFrame();
        frame.add(new JLabel("Hello World", SwingConstants.CENTER));
        frame.setSize(200, 100);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
	
}

JavaFX and FXML files

[edit | edit source]
package example;

public class FXMLDocumentController extends Application implements Initializable  {
    
    @Override
    public void start(Stage stage) throws Exception {
        Parent root = FXMLLoader.load(getClass().getResource("FXMLDocument.fxml"));
        Scene scene = new Scene(root);
        stage.setScene(scene);
        stage.show();
    }

    @FXML
    private Label label;
    
    @Override
    public void initialize(URL url, ResourceBundle rb) {
         label.setText("Hello World!");
    }
    
    public static void main(String[] args) {
        launch(args);
    }
    
}
<?xml version="1.0" encoding="UTF-8"?>

<?import java.lang.*?>
<?import java.util.*?>
<?import javafx.scene.*?>
<?import javafx.scene.control.*?>
<?import javafx.scene.layout.*?>

<AnchorPane id="AnchorPane" prefHeight="200" prefWidth="320" xmlns:fx="http://javafx.com/fxml/1" fx:controller="example.FXMLDocumentController">
    <children>
        <Label layoutX="126" layoutY="80" minHeight="16" minWidth="69" fx:id="label" />
    </children>
</AnchorPane>

GTK (java-gnome)

[edit | edit source]
import org.gnome.gdk.*;

class GdkSimple extends Window {

    public GdkSimple() {
        setTitle("Example");
        connect((DeleteEvent)(source, event) -> {
            Gtk.mainQuit();
            return false;
        });
        add(new Label("Hello World"));
        setDefaultSize(250, 150);
        setPosition(WindowPosition.CENTER);
        show();
    }

    public static void main(String[] args) {
        Gtk.init(args);
        new GdkSimple(); 
        Gtk.main(); 
    } 
}

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 )

[edit | edit source]
#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

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

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!" 
    Quit
FunctionEnd

OCaml

[edit | edit source]

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

(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
   DIALOG
ENDP

Pure Data

[edit | edit source]

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

[edit | edit source]

Tkinter

[edit | edit source]
from Tkinter import Tk, Label
 
root = Tk()
Label(root, text="Hello, world!").pack()
 
root.mainloop()

Using PyQt:

import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

app = QApplication(sys.argv)
label = QLabel("Hello, World!")
label.show()
sys.exit(app.exec_())

PyGTK

[edit | edit source]
from gtk import *

label = Label("Hello, world!")
label.show()

window = Window()
window.add(label)
window.show()

main()

Pygame

[edit | edit source]
import pygame
import sys

pygame.init()
screen = pygame.display.set_mode((512, 256), 0, 32)
f = pygame.font.SysFont(None, 32)
t = f.render("Hello, world!", True, (255, 255, 255))
tR = t.get_rect()
screen.blit(t, tR)
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
    pygame.display.update()

Kivy multi-platform framework

import kivy

from kivy.app import App
from kivy.uix.label import Label

class MyApp(App):
    def build(self):
        return Label(text='Hello world')

MyApp().run()

Qt toolkit (in C )

[edit | edit source]
 #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

[edit | edit source]
 view layout [text "Hello, world!"]
 view [text "Hello, world!"]

Robotic (MegaZeux)

[edit | edit source]
* "Hello, world!"
end

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

<< "Hello, world!" MSGBOX >>
Hello ()
TEXT "Hello, world!"

Ruby with WxWidgets

[edit | edit source]
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
 end
end

HelloWorldApp.new.main_loop

Ruby with GTK

[edit | edit source]
require 'gtk2'

Gtk.init
window = Gtk::Window.new
window.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_all
Gtk.main

Ruby with Tk

[edit | edit source]
require 'tk'

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

Tk.mainloop

Smalltalk

[edit | edit source]

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 with Java

[edit | edit source]
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 ();
     }
}
label .l -text "Hello, world!"
pack .l

and the same in one line

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

Tcl with Tk

[edit | edit source]
package require Tk
tk_messageBox -message "Hello, world!"

or

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

Ubercode

[edit | edit source]
 Ubercode 1 class Hello
 public function main()
 code
   call Msgbox("Hello", "Hello, world!")
 end function
 end class

Uniface

[edit | edit source]
 message "Hello, world!"

Virtools

[edit | edit source]
void main () 
{ 
  String s = "Hello World."; 
  bc.OutputToConsole (s); 
}
Sub Main()
    MsgBox "Hello, world!"
End Sub

Visual Basic .NET 2003/2005

[edit | edit source]
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 Sub
End Class

or using a class;

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

Visual Prolog (note box)

[edit | edit source]
#include @"pfc\vpi\vpi.ph"

goal
  vpiCommonDialogs::note("Hello, world!").

Windows API (in C)

[edit | edit source]

This uses the Windows API to create a full window containing the text.

/*
 Name: Win32 example
 Copyright: GLP
 Author: Ryon S. Hunter
 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;
}

In the Open event handler of the default window:

MsgBox("Hello world!")
<?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>

Maple

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

Document formats

[edit | edit source]

ASCII

[edit | edit source]

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 01110111
08-0E: 01101111 01110010 01101100 01100100 00100001 00001101 00001010

Page description languages

[edit | edit source]

XHTML 1.1

[edit | edit source]

(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/xhtml11.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
  <head>
   <title>Hello, world!</title>
  </head>
  <body>
   <p>Hello, world!</p>
  </body>
 </html>

Simple

[edit | edit source]
<html>
  <body>
    Hello, world!
  </body>
</html>

Informal

[edit | edit source]

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)

[edit | edit source]
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Strict//EN" "http://www.w3.org/TR/html4/strict.dtd">
<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)

[edit | edit source]

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

[edit | edit source]
<!DOCTYPE html>
<html>
  <head>
    <title>Hello, World!</title>
  </head>
  <body>
    <h1>Hello, world!</h1>  
  </body>
</html>

Markdown

[edit | edit source]
Hello, World!

MediaWiki/Wikitext

[edit | edit source]
Hello, World!
%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

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

PostScript

[edit | edit source]
 % Displays on console.
 (Hello, world!) =
 %!
 % Displays as page output.
 /Courier findfont
 24 scalefont
 setfont
 100 100 moveto
 (Hello, world!) show
 showpage
{\rtf1\ansi\deff0
{\fonttbl {\f0 Courier New;}}
\f0\fs20 Hello, world!
}
 <?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>
 Hello, world!
 \bye

LaTeX 2ε

[edit | edit source]
 \documentclass{article}
 \begin{document}
   Hello, world!
 \end{document}

ConTeXt

[edit | edit source]
  \starttext
    Hello, world!
  \stoptext

Media-based scripting languages

[edit | edit source]

AviSynth

[edit | edit source]
 BlankClip()
 Subtitle("Hello, world!")

(Creates a video with default properties)

Lingo (Macromedia Director scripting language)

[edit | edit source]
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

[edit | edit source]
 #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

[edit | edit source]

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.

<:48:x<:65:=<:6C:$=$=$$~<:03: $<:2c:~$~<:c:x-$<:77:
~$~<:8:x-$~<:03: $~<:06:x-$x<:0e:x-$=x<:43:x-$

Alef

[edit | edit source]
  use java.lang.*;
  main
  {
      System->out->println[ 'Hello, world!' ];
  }
 ■→→■↓■←■←■↓■→→■  /* makes H */
 →→■↓■↑↑↑■        /* makes I */

Befunge

[edit | edit source]
 "!dlrow olleH">v
                :
                ,
               ^_@
 v v"Hello, world!!"<
 >                  ^
 > >:#v_@
 ^   .<
 0"!dlrow olleH">,:#<_@

Binary lambda calculus

[edit | edit source]

As documented at http://www.ioccc.org/2012/tromp/hint.html (any of the 16 ASCII characters from ' ' to '/' can be used at the start)

   !Hello, world

BlooP, FlooP

[edit | edit source]

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.
                        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'

Hello, world! Souffle by David Morgan-Mar.

Hello World Souffle.

This recipe prints the immortal words "Hello world!", in a basically brute force way. It also makes a lot of food for one person.

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.

Later Mike Worth wrote tastier and actually functional recipe.

Hello World Cake with Chocolate sauce.

This prints hello world, while being tastier than Hello World Souffle. The main
chef makes a " world!" cake, which he puts in the baking dish. When he gets the
sous chef to make the "Hello" chocolate sauce, it gets put into the baking dish
and then the whole thing is printed when he refrigerates the sauce. When
actually cooking, I'm interpreting the chocolate sauce baking dish to be
separate from the cake one and Liquify to mean either melt or blend depending on
context.

Ingredients.
33 g chocolate chips
100 g butter
54 ml double cream
2 pinches baking powder
114 g sugar
111 ml beaten eggs
119 g flour
32 g cocoa powder
0 g cake mixture

Cooking time: 25 minutes.

Pre-heat oven to 180 degrees Celsius.

Method.
Put chocolate chips into the mixing bowl.
Put butter into the mixing bowl.
Put sugar into the mixing bowl.
Put beaten eggs into the mixing bowl.
Put flour into the mixing bowl.
Put baking powder into the mixing bowl.
Put cocoa  powder into the mixing bowl.
Stir the mixing bowl for 1 minute.
Combine double cream into the mixing bowl.
Stir the mixing bowl for 4 minutes.
Liquify the contents of the mixing bowl.
Pour contents of the mixing bowl into the baking dish.
bake the cake mixture.
Wait until baked.
Serve with chocolate sauce.

chocolate sauce.

Ingredients.
111 g sugar
108 ml hot water
108 ml heated double cream
101 g dark chocolate
72 g milk chocolate

Method.
Clean the mixing bowl.
Put sugar into the mixing bowl.
Put hot water into the mixing bowl.
Put heated double cream into the mixing bowl.
dissolve the sugar.
agitate the sugar until dissolved.
Liquify the dark chocolate.
Put dark chocolate into the mixing bowl.
Liquify the milk chocolate.
Put milk chocolate into the mixing bowl.
Liquify contents of the mixing bowl.
Pour contents of the mixing bowl into the baking dish.
Refrigerate for 1 hour.

False

[edit | edit source]
"Hello, World!
"

The newline before the terminating quote mark is necessary.

H

INTERCAL programming language

[edit | edit source]
    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

[edit | edit source]
HAI;
    CAN HAS STDIO?;
    VISIBLE "Hello, World!";
KTHXBYE;

LOLGraphics

[edit | edit source]
HAI 3.4 0 100
IM IN UR CODE EXECUTIN UR KOMANDZ

PLZ PRINT TEXT HELLO WORLD!
 
IM OUTTA UR CODE

Malbolge programming language

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

P programming language

[edit | edit source]
"Hello, world!\n"

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


Piet programming language uses only colors.

Hello world in piet (see from 41:40 minute on "The Art of Code" on YouTube)
Shout "Hello, world!"

Shakespeare

[edit | edit source]
The Infamous Hello World Program.
 
Romeo, a young man with a remarkable patience.
Juliet, a likewise young woman of remarkable grace.
Ophelia, a remarkable woman much in dispute with Hamlet.
Hamlet, the flatterer of Andersen Insulting A/S.
  
                  Act I: Hamlet's insults and flattery.
  
                  Scene I: The insulting of Romeo.
 
[Enter Hamlet and Romeo]

Hamlet:
 You lying stupid fatherless big smelly half-witted coward!
 You are as stupid as the difference between a handsome rich brave
 hero and thyself! Speak your mind!

 You are as brave as the sum of your fat little stuffed misused dusty
 old rotten codpiece and a beautiful fair warm peaceful sunny summer's
 day. You are as healthy as the difference between the sum of the
 sweetest reddest rose and my father and yourself! Speak your mind!

 You are as cowardly as the sum of yourself and the difference
 between a big mighty proud kingdom and a horse. Speak your mind.

 Speak your mind!

[Exit Romeo]

                    Scene II: The praising of Juliet.

[Enter Juliet]

Hamlet:
 Thou art as sweet as the sum of the sum of Romeo and his horse and his
 black cat! Speak thy mind!

[Exit Juliet]

                    Scene III: The praising of Ophelia.

[Enter Ophelia]

Hamlet:
 Thou art as lovely as the product of a large rural town and my amazing
 bottomless embroidered purse. Speak thy mind!

 Thou art as loving as the product of the bluest clearest sweetest sky
 and the sum of a squirrel and a white horse. Thou art as beautiful as
 the difference between Juliet and thyself. Speak thy mind!

[Exeunt Ophelia and Hamlet]


                    Act II: Behind Hamlet's back.

                    Scene I: Romeo and Juliet's conversation.

[Enter Romeo and Juliet]

Romeo:
 Speak your mind. You are as worried as the sum of yourself and the
 difference between my small smooth hamster and my nose. Speak your
 mind!

Juliet:
 Speak YOUR mind! You are as bad as Hamlet! You are as small as the
 difference between the square of the difference between my little pony
 and your big hairy hound and the cube of your sorry little
 codpiece. Speak your mind!

[Exit Romeo]

                    Scene II: Juliet and Ophelia's conversation.

[Enter Ophelia]

Juliet:
 Thou art as good as the quotient between Romeo and the sum of a small
 furry animal and a leech. Speak your mind!

Ophelia:
 Thou art as disgusting as the quotient between Romeo and twice the
 difference between a mistletoe and an oozing infected blister! Speak
 your mind!

[Exeunt]

SNUSP

[edit | edit source]
   /e                             .\  
   ./\/\/\  /   \!>.   o.l.       l/                  #/?\  
$H!\      \     \comma.------------ .<w        .\ /?\<!\-/
   /      /  /\                      /.--------o/ \-/!.          /?\n
 /=\      \  \\!=      \             \r   .l------.d--------.> .!\-/
 \!\/\/\/\/ \          /

Modular SNUSP:

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

Spoon (programming language)

[edit | edit source]
1111110010001011111111111101100000110100010100101111111111001000101111111111011000001101 0100101011111110010100010101110010100101111001000101111111111101100000110100010100111110 0100010000000000000011000001101000101001101101101101111100100010111110110000011010001010 0100100010101110010100000000000000000000010100000000000000000000000000010100100101001010

Super NAND Time!!

[edit | edit source]
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 44
31 ((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

[edit | edit source]
"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

[edit | edit source]
�gin @jump $main
%main.0 @echo %msg
%main.1 @end
%main.count 2
%msg Hello, world!

This=That

[edit | edit source]
x=Hello,world!
x=print

Unlambda programming language

[edit | edit source]
  `r```````````.H.e.l.l.o. .w.o.r.l.di

Var'aq programming language

[edit | edit source]

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

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

Whitespace

[edit | edit source]

Note that whitespace has been highlighted (Space, Tab)

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

XS programming language

[edit | edit source]
<print>Hello, world!</print>

Ya programming language

[edit | edit source]
@HelloWorld.Ya;
using <stdio.h>;
$int($char[][] args) main
	printf("Hello, %s!\n", args.Length > 1 ? args[1] : "World");
	return 0;

DUNNBOL1

[edit | edit source]

A code language that draws in binary on a braille plotter.

BGN GRPLOT BIN
DRAWPLOT

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0011100111001111111001110000000011100000000001111100000000001000001000011111000001111100000100000000011111110000
0001000010000100001000100000000001000000000010000010000000001000001000100000100010000010000100000000010000001000
0001000010000100000000100000000001000000000010000010000000001000001000100000100010000010000100000000010000001000
0001111110000111100000100000000001000000000010000010000000001001001000100000100011111110000100000000010000001000
0001000010000100000000100000000001000000000010000010000000001011101000100000100010000001000100000000010000001000
0001000010000100001000100000000001000000000010000010000000001100011000100000100010000000100100000000010000001000
0011100111001111111001111111100011111111000001111100000000001000001000011111000010000000100111111100011111110000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

ENDDRAW
END

The OO language looks like C.

use System.Windows.Forms;

class HelloWorld extends System.Windows.Forms
{
    protected:
        String hw;
    construct HelloWorld()
    {
        this.hw = 'Hello, world!';
    }
    public void function show()
    {
        MessageBox.show(this.hw, '');
    }
}

Skript

[edit | edit source]

Copy this and paste in ChatGPT, on a new chat:

Output: Hello, world!

A longer version, which still prints "Hello, world!":

CreateBuf: $Hello$
$Hello$: {
[H]
[e]
[l]
[l]
[o]
[,]
[32] @ The ASCII value for space
[w]
[o]
[r]
[l]
[d]
[!]
}
OpenBuf: $Hello$
JoinAllChars: $Hello$ => $Hello2$
Output: $Hello2$
CloseBuf: $Hello$

Note: The first method is tested and it's working. I don't know about the second one!