User:K8joc8ohGee9j/sandbox

ABAP

REPORT ZHELLOWORLD.
WRITE 'Hello, world!'.

ActionScript 3.0

trace ("Hello, world!");

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

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

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

Ada

with Ada.Text_IO;

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

Adventure Game Studio Script

Display("Hello, world!");

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

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

Agda

module hello where
  open import IO
  main = run (putStrLn "Hello World!")

Compiled using Agda 2.4.02. Note that the IO module is part of the Haskell FFI. (You may need to run cabal install inside the ffi folder of your agda standard library.)

ALGOL

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

ALGOL 68

print("Hello, world!")

Amiga E

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

APL

'Hello, world!'

AppleScript

display dialog "Hello, world!"

or if you want a button to trigger the dialog:

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

helloWorld()

AS/400 Control Language

PGM
SNDPGMMSG MSG('Hello, world!')
ENDPGM

ASP.Net

Response.Write("Hello World!");

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

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

Assembly language — MOS Technology 6502, Acorn MOS

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

Assembly language — ARM, BBC BASIC inline assembler

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

Assembly language — Intel 8086 Microprocessor Emulator - emu8086

Without using print procedure :

; this example prints out  "hello world!"
; by writing directly to video memory.
; in vga memory: first byte is ascii character, byte that follows is character attribute.
; if you change the second byte, you can change the color of
; the character even after it is printed.
; character attribute is 8 bit value,
; high 4 bits set background color and low 4 bits set foreground color.

; hex    bin        color
; 
; 0      0000      black
; 1      0001      blue
; 2      0010      green
; 3      0011      cyan
; 4      0100      red
; 5      0101      magenta
; 6      0110      brown
; 7      0111      light gray
; 8      1000      dark gray
; 9      1001      light blue
; a      1010      light green
; b      1011      light cyan
; c      1100      light red
; d      1101      light magenta
; e      1110      yellow
; f      1111      white
 
org 100h

; set video mode    
mov ax, 3     ; text mode 80x25, 16 colors, 8 pages (ah=0, al=3)
int 10h       ; do it!

; cancel blinking and enable all 16 colors:
mov ax, 1003h
mov bx, 0
int 10h

; set segment register:
mov     ax, 0b800h
mov     ds, ax

; print "hello world"
; first byte is ascii code, second byte is color code.

mov [02h], 'H'
mov [04h], 'e'
mov [06h], 'l'
mov [08h], 'l'
mov [0ah], 'o'
mov [0ch], ','
mov [0eh], 'W'
mov [10h], 'o'
mov [12h], 'r'
mov [14h], 'l'
mov [16h], 'd'
mov [18h], '!'

; color all characters:
mov cx, 12  ; number of characters.
mov di, 03h ; start from byte after 'h'

c:  mov [di], 11101100b   ; light red(1100) on yellow(1110)
    add di, 2 ; skip over next ascii code in vga memory.
    loop c

; wait for any key press:
mov ah, 0
int 16h

ret

Assembly language — MOS Technology 6502, CBM KERNAL

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

Assembly language — Motorola 68000, Atari TOS

; Assmebled with Devpac and VASM
; VASM -devpac -m68000 -no-opt -nosym -Ftos

;Cconws
	pea		Text(PC)
	move.w	#9,-(SP)
	trap	#1
	addq.l	#6,SP

;Pterm0
	clr.w	-(A7)
	trap	#1
	
Text
	dc.b	"Hello, world!",0

Assembly language — x86 DOS

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

.model tiny
.code
org 100h

main  proc

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

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

hello_message db 'Hello, world!$'

main  endp
end   main

Assembly language — x86 Windows

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

         .486p
         .model  flat,STDCALL
include  win32.inc

extrn            MessageBoxA:PROC
extrn            ExitProcess:PROC

.data

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

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

         push 0
         call ExitProcess
ends
end Start

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

# The helloWorld.s file contains the source for a linux-x86_64 hello world
# example using the new 64 bit system call ABI.
# 2014 John Wassilak
#
# Compile with :
#     as -o helloWorld.o helloWorld.s
#     ld -e main -o helloWorld -s -Os helloWorld.o
.section .rodata                       # The rodata section contains the
                                       #     constants used by the program.
string: .ascii "Hello, world!\n"       # The string constant contains the
                                       #     string to be printed.
length: .quad . - string               # The length constant contains the
                                       #     length of the string constant.
.section .text                         # The text section contains the
                                       #     executable instructions of the
                                       #     program.
.globl main                            # Declare the main symbol as global so
                                       #     that the linker can see it.
main:                                  # The main symbol is the entry point of
                                       #     the program.
mov   $1, %rax                         # Move 1(sys_write) into rax.
mov   $1, %rdi                         # Move 1(fd stdOut) into rdi.
mov   $string, %rsi                    # Move the location of the string
                                       #     constant into rsi.
mov   length, %rdx                     # Move the length of the string
                                       #     constant into rdx.
syscall                                # Print the string constant to stdOut by
                                       #     making a system call.
                                       #     written = sys_write(
                                       #         stdOut, string, length
                                       #     )
mov   %rax, %rdi                       # Move the number of bytes written to
                                       #     rdi.
mov   $60, %rax                        # Move 60(sys_exit) into rax.
syscall                                # Terminate the process, returning the
                                       #     number of bytes written by
                                       #     sys_write as the exit status.
                                       #     sys_exit(written)

Assembly language — x86-64 Unix-like operating systems, NASM syntax

; MacOS X: /usr/local/bin/nasm -f macho64 *.s && ld -macosx_version_min 10.7 *.o
; Solaris/FreeBSD/DragonFly: nasm -f elf64 -D UNIX *.s && ld *.o
; NetBSD: nasm -f elf64 -D UNIX -D NetBSD *.s && ld *.o
; OpenBSD: nasm -f elf64 -D UNIX -D OpenBSD *.s && ld -static *.o
; OpenIndiana: nasm -f elf64 -D UNIX *.s && ld -m elf_x86_64 *.o
; Linux: nasm -f elf64 *.s && ld *.o

%ifdef  NetBSD
section .note.netbsd.ident
        dd      7,4,1
        db      "NetBSD",0,0
        dd      200000000       ; amd64 supported since 2.0
%endif

%ifdef  OpenBSD
section .note.openbsd.ident
        align   2
        dd      8,4,1
        db      "OpenBSD",0
        dd      0
        align   2
%endif

section .text

%ifidn __OUTPUT_FORMAT__, macho64       ; MacOS X
        %define SYS_exit        0x2000001
        %define SYS_write       0x2000004

        global  start
        start:
%elifidn __OUTPUT_FORMAT__, elf64
        %ifdef  UNIX            ; Solaris/OI/FreeBSD/NetBSD/OpenBSD/DragonFly
                %define SYS_exit        1
                %define SYS_write       4
        %else                   ; Linux
                %define SYS_exit        60
                %define SYS_write       1
        %endif

        global  _start
        _start:
%else
        %error  "Unsupported platform"
%endif

        mov     rax,SYS_write
        mov     rdi,1           ; stdout
        mov     rsi,msg
        mov     rdx,len
        syscall
        mov     rax,SYS_exit
        xor     rdi,rdi         ; exit code 0
        syscall

section .data

msg     db      "Hello, world!",10
len     equ     $-msg

Assembly language — Z80

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

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

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

And in pure hex:

219F9D
EF0A45
EF2E45
C9
48692100

AutoHotkey

Msgbox, Hello, world!

Traytip,, Hello, world!

AutoIt

#include <MsgBoxConstants.au3>

Msgbox($MB_ICONINFORMATION, "", "Hello, world!")

AWK

BEGIN { print "Hello, world!" }

Axe Parser — TI-83/TI-84 plus and SE

ClrHome
Disp "HELLO, WORLD!"
Return

Backbone.js

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>hello-backbonejs</title>
</head>
<body>
<script src="http://code.jquery.com/jquery-1.11.0.js"></script>
<script src="https://raw.githubusercontent.com/douglascrockford/JSON-js/master/json2.js"></script>
<script src="http://underscorejs.org/underscore.js"></script>
<script src="http://backbonejs.org/backbone.js"></script>

<script>
(function($){
  var MyView = Backbone.View.extend({
     initialize: function(){
       this.render();
    },
    render: function(){
      $('body').append("<h4>hello world</h4>");
    }
  });
  var myView = new MyView();
})(jQuery);
</script>
<div>test</div>
</body>
</html>

BASH

echo "Hello World"

BASIC

PRINT "Hello, world!"

Batch File

@echo Hello, world!

BCPL

GET "LIBHDR"

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

BennuGD

import "mod_say"

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

Befunge

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

Boo

print "Hello World!"

brainfuck

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

< +++++ +++ .           print 'w'
 ----- --- .            print 'o'
+++ .                   print 'r'
----- - .               print 'l'
----- --- .             print 'd'
> + .                   print '!'
> .                     print '\n'

==

#include <stdio.h>

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

C++

#include <iostream>

int main()
{
    std::cout << "Hello, world!\n";
}

C++/CLI

using namespace System;

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

C++/CX

#include "stdafx.h"
#using <Platform.winmd>
using namespace Platform;

[MTAThread]
int main(Array<String^>^ args)
{
    String^ message("Hello World!");
    Details::Console::WriteLine(message);
}

C++/Qt

#include <QCoreApplication>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    qDebug() << "Hello World!";

    return a.exec();
}

Via a GUI QLabel widget:

#include <QApplication>
#include <QLabel>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QLabel label( "Hello World!" );
    label.show();
    return a.exec();
}

Via a GUI static QMessageBox dialog:

#include <QApplication>
#include <QMessagebox>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QMessageBox::information( NULL, "Hello World!", "Hello World!" );
    return a.exec();
}

C#

In a console or terminal:

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

Via a GUI message box:

using System.Windows.Forms;
class Program
{
    public static void Main(string[] args)
    {
        MessageBox.Show("Hello, World!");
    }
}

Caché ObjectScript

w "Hello, World!"

Casio BASIC

"HELLO, WORLD!"

Ceylon

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

Clipper

? "Hello World"

Clojure

Console version:

(println "Hello, world!")

GUI version:

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

COBOL

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

CoffeeScript

To display an alert dialog box:

alert 'Hello, world!'

To write to a console or debugging log:

console.log 'Hello, world!'

COMAL-80

10 PRINT "Hello, world!"

Common Intermediate Language

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

ColdFusion Markup Language (CFML)

CF Script:

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

CFML Tags:

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

==

import std.stdio;

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

Dart

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

DCL

WRITE SYS$OUTPUT "Hello, world!"

Delphi

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

==

Main article: E (programming language)

println("Hello, world!")

Eiffel

class
    HELLO_WORLD
create
    make
feature
    make
        do
            print ("Hello, world!%N")
        end
end

(message "Hello, World!") </syntaxhighlight>

Euphoria

puts(1,"Hello World")

Erlang

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

Ezhil

பதிப்பி "உலகே வணக்கம்"

F#

printfn "Hello, world!"

Falcon

 printl( "Hello, world!" )

or

 > "Hello, world!"

Filemaker

#Hello World using Filemaker Pro
Show Custom Dialog ["Hello, world" ; "Hello, world"]

Flowgorithm

Forth

." Hello, world! "

Fortran

Fortran 90 and later:

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

OR

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

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

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

OR

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

FreeBASIC

print "Hello, world!"

Frost

import "io.frost";

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

Go

package main

func main() {
	println("Hello, world!")
}

Groovy

println "Hello, world!"

GraalScript 2

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

Haskell

main = putStrLn "Hello, world!"

Haxe

class Test {
    static function main() {
        trace("Hello World !");
    }
}

HTML

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

HOP

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

IDL

print, "Hello, world!"
end

INTERCAL

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

Io

 "Hello, world!" println

ISLISP

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

Inform7

when play begins, say "Hello World!"

==

  'Hello, world!'

Java

In console:

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

or in window with Swing:

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

or in dialog:

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

Test-Driven Development with Java

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

import static org.junit.Assert.assertEquals;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import org.junit.Test;

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

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

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

JavaScript

To write to a console or debugging log:

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

To display an alert dialog box:

alert('Hello, world!');

To write to an HTML document:

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

Using Mozilla's Rhino:

print('Hello, world!');

Julia

  println("Hello world!")

Leet

Gr34t l33tN3$$?
M3h...
iT 41n't s0 7rIckY.

l33t sP33k is U8er keWl 4nD eA5y wehn u 7hink 1t tHr0uGh.
1f u w4nn4be UB3R-l33t u d3f1n1t3lY w4nt in 0n a b4d4sS h4xX0r1ng s1tE!!! ;p
w4r3Z c0ll3cT10n2 r 7eh l3Et3r!

Qu4k3 cL4nS r 7eh bE5t tH1ng 1n teh 3nTIr3 w0rlD!!!
g4m3s wh3r3 u g3t to 5h00t ppl r 70tAl1_y w1cK1d!!
I'M teh fr4GM4stEr aN I'lL t0t41_1Ly wIpE teh phr34k1ng fL00r ***j3d1 5tYlE*** wItH y0uR h1dE!!!! L0L0L0L!
t3lEphR4gG1nG l4m3rs wit mY m8tes r34lLy k1kK$ A$$

l33t hAxX0r$ CrE4t3 u8er- k3wL 5tUff lIkE n34t pR0gR4mm1nG lAnguidGe$...
s0m3tIm3$ teh l4nGu4gES l00k jUst l1k3 rE41_ 0neS 7o mAkE ppl Th1nk th3y'r3 ju$t n0rMal lEE7 5pEEk but th3y're 5ecRetLy c0dE!!!!
n080DY unDer5tAnD$ l33t SpEaK 4p4rT fr0m j3d1!!!!!
50mE kId 0n A me$$4gEb04rD m1ghT 8E a r0xX0r1nG hAxX0r wH0 w4nT2 t0 bR34k 5tuFf, 0r mAyb3 ju5t sh0w 7eh wAy5 l33t ppl cAn 8E m0re lIkE y0d4!!! hE i5 teh u8ER!!!!
1t m1ght 8E 5omE v1rus 0r a Pl4ySt4tI0n ch34t c0dE.
1t 3v3n MiTe jUs7 s4y "H3LL0 W0RLD!!!" u ju5t cAn'T gu3s5.
tH3r3's n3v3r anY p0iNt l00KiNg sC3pT1c4l c0s th4t, be1_1Ev3 iT 0r n0t, 1s whAt th1s 1s!!!!!

5uxX0r5!!!L0L0L0L0L!!!!!!!

Linden Scripting Language

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

Lisp

(princ "Hello, world!")

Logo

print [Hello, world!]

LOLCODE

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

Lua

print("Hello, world!")

M4

Hello, world!

Malbolge

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

Mathematica

Print["Hello, world!"]

Maple

print(`Hello, world!`);

MATLAB

disp('Hello, world!')

Miranda

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

mIRC Script

echo -a Hello, world!

Modula-2

MODULE Hello;
FROM STextIO IMPORT WriteString;
BEGIN
  WriteString("Hello World!");
END Hello.

MUMPS

w "Hello, world!"

Oberon

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

Obix

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

Objective-C

#import <stdio.h>
#import <Foundation/Foundation.h>

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

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

#import <stdio.h>
#import <objc/Object.h>

@interface Hello: Object
- (void) say;
@end

@implementation Hello
- (void) say {
  printf("Hello, world!\n");
}
@end

int main() {
  Hello *hello = [Hello new];
  [hello say];
  [hello free];
  return 0;
}

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

@interface Hello:NSObject
- (void) say;
@end
@implementation Hello
- (void) say {
   NSLog(@"Hello, world!");
}
@end

int main(int argc, char *argv[])
{
    NSAutoreleasePool *p = [[NSAutoreleasePool alloc] init];
    Hello *hello = [Hello new];
    [hello say];
    [hello release];
    [p release];
    return 0;
}

Modern (llvm, ARC memory management):

@interface Hello:NSObject
- (void) say;
@end
@implementation Hello
- (void) say {
   NSLog(@"Hello, world!");
}
@end

int main(int argc, char *argv[])
{
    @autoreleasepool {;
        [[Hello new] say];
    }
    return 0;
}

OCaml

 print_endline "Hello, world!"

Opa

A "hello world" web server:

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

OpenEdge Advanced Business Language (PROGRESS)

 DISPLAY "Hello World!".

Oriel

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

Oz

{Show 'Hello World'}

Pascal

program HelloWorld;

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

Pawn

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

Perl 5

print "Hello, world!\n";

Or

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

PHP

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

or

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

or

<?= 'Hello, world!' ?>

or

Hello world

This works because php will echo by default

PL/SQL

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

PostScript

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

PowerShell

'Hello, world!'

Processing

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

Prolog

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

Python

Python 2:

print "Hello, world!"

Python 3:

print("Hello, world!")

Python IDLE:

"Hello, world!"

Qalb (قلب)

‫(قول "مرحبا يا عالم!")

==

cat('Hello, world!\n')

Racket

Main article: Racket (programming language)

Trivial "hello world" program:

"Hello, world!"

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

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

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

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

In Scribble, Racket's documentation language:

Hello, world!

Rebol

print "Hello, world!"

Red

Red [
    Title: "Simple hello world script"
]

print "Hello World!"

REXX

say Hello, world!

RPL

<< "Hello, world!" MSGBOX >>

RPG (free-format)

/free
dsply 'Hello, world!';
*inlr = *on;
/end-free

RTL/2

TITLE Hello, world!;

LET NL=10;

EXT PROC(REF ARRAY BYTE) TWRT;

ENT PROC INT RRJOB();
    TWRT("Hello, world!#NL#");
    RETURN(1);
ENDPROC;

Ruby

puts "Hello, world!"

Rust

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

Scala

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

or

object HelloWorld {
  def main(args : Array[String]) {
    println("Hello, world!")
  }
}

Scheme

(display "Hello, world!")

Scratch

Hello, World! in Scratch

Sed

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

Shell

echo Hello, world!

SimpleC

OUT<"Hello, world!"

Simula

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

Small Basic

TextWindow.WriteLine("Hello, World!")

Smalltalk

Transcript show: 'Hello, world!'.

SmileBASIC

?"Hello, world!

or

PRINT "Hello, world!"

SNOBOL

  OUTPUT = 'Hello, world!'
END

Speakeasy

As an interactive statement :

"Hello, world!"

As a program :

program hello
   "Hello, world!"
end

SQL

SELECT 'Hello, world!' FROM DUMMY; -- DUMMY is a standard table in SAP HANA.
SELECT 'Hello, world!' FROM DUAL; -- DUAL is a standard table in Oracle.
SELECT 'Hello, world!' -- Works for SQL Server, Microsoft Access, PostgreSQL and MySQL.

Stata

display "Hello, world!"

Swift

println("Hello, world!")

Tcl

puts "Hello, world!"

TI-BASIC

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

or

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

For m68k calculators:

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

For Ti Nspire/CAS:

text"HELLO, WORLD!"

For Ti Nspire CX:

text "HELLO, WORLD!"

or

Disp "HELLO, WORLD"

Turing

put "Hello World!"

TypeScript

class Greeter {
    constructor(public greeting: string) { }
    greet() {
        return "<h1>" + this.greeting + "</h1>";
    }
};
var greeter = new Greeter("Hello, world!");
var str = greeter.greet();
document.body.innerHTML = str;

UnrealScript

Main article: UnrealScript

Log("Hello, world!");

Vala

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

VBScript

MsgBox("Hello, World!")

Verilog

module hello();

initial begin

	$display("Hello, world!");
        $finish;
end

endmodule

VHDL

entity hello_world is
end entity;

architecture behavior of hello_world is
begin
  PROCESS
  begin
    report "Hello, world!";
  end PROCESS;
end architecture;

Visual Basic

 MsgBox "Hello, world!"

Visual Basic .NET

In a console or terminal window:

Module Module1
    Sub Main()
        Console.WriteLine("Hello, world!")
    End Sub
End Module

In a message box:

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

XSLT

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

Zebra

^XA^LH30,30
^FO20,10^ADN,90,50^AD^FDHello, World!^FS
^XZ