یک **برنامه Hello World،** یک برنامهٔ رایانه‌ای ساده است که جمله «!Hello, world» را در صفحۀ نمایش چاپ می‌کند. معمولاً ساده‌ترین برنامهٔ ممکنی است که می‌توان در زبان‌های برنامه‌نویسی مختلف نوشت و یک عمل سنتی است که بسیاری از برنامه‌نویسان که قصد آموزش یک زبان برنامه‌نویسی را دارند، توصیه به نوشتن آن می‌کنند که اولین قدم در یادگیری آن زبان برنامه‌نویسی است. بیشتر از این برنامه برای مقایسه نحو دو زبان مختلف استفاده می‌شود. در زیر فهرستی از برنامه‌های Hello World مرسوم در ۹۱ زبان برنامه‌نویسی آمده‌است.

آباپ
----

مقالهٔ اصلی: آباپ

```
REPORT HELLOWORLD.
WRITE 'Hello, world!'.

```

اکشن‌اسکریپت
------------

مقالهٔ اصلی: اکشن‌اسکریپت

```
trace ("Hello, world!");

```

یا:

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

```

ایدا
----

مقالهٔ اصلی: ایدا (زبان برنامه‌نویسی)

```
with Ada.Text\_IO;

procedure Hello\_World is
 use Ada.Text\_IO;
begin
    Put\_Line("Hello, world!");
end;

```

Adventure Game Studio Script
----------------------------

مقالهٔ اصلی: Adventure Game Studio

```
Display("Hello, world!");

```

یا:

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

```

الگول
-----

مقالهٔ اصلی: الگول

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

ALGOL 68
--------

مقالهٔ اصلی: ALGOL 68

```
print("Hello, world!")
```

Amiga E
-------

مقالهٔ اصلی: Amiga E
```
PROC main()
  WriteF('Hello, world!')
ENDPROC
```

ای‌پی‌ال
--------

مقالهٔ اصلی: ای‌پی‌ال
```
'Hello, world'

```

Assembly Language — MOS Technology 6502, CBM KERNEL
---------------------------------------------------

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

```

اسمبلی x86 داس
--------------

مقالهٔ اصلی: اسمبلی

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

```

زبان اسمبلی x86 ویندوز ۳۲ بیتی
------------------------------

مقالهٔ اصلی: اسمبلی

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

```

زبان اسمبلی - x86-64 لینوکس، ای‌تی‌اندتی
----------------------------------------

مقالهٔ اصلی: Assembly language

```
.section .rodata
string:
.ascii "Hello, world!\n\0"
length:
.quad. -string #Dot = 'here'

.section .text
.globl \_start #Make entry point visible to linker
\_start:
movq $4, %rax #4=write
movq $1, %rbx #1=stdout
movq $string, %rcx
movq length, %rdx
int $0x80 #Call Operating System
movq %rax, %rbx #Make program return syscall exit status
movq $1, %rax #1=exit
int $0x80 #Call System Again

```

زبان اسمبلی - Z80
-----------------

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

```

AutoHotkey
----------

مقالهٔ اصلی: AutoHotkey

```
Msgbox, Hello, world!

```

```
Traytip,, Hello, world!

```

AutoIt
------

مقالهٔ اصلی: AutoIt

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

```

AWK
---

مقالهٔ اصلی: AWK

```
BEGIN { print "Hello, world!" }

```

بیسیک
-----

مقالهٔ اصلی: بیسیک

```
PRINT "Hello, world!"

```

Batch File
----------

مقالهٔ اصلی: Batch file

```
@echo Hello, world!

```

BCPL
----

مقالهٔ اصلی: BCPL
```
GET "LIBHDR"

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

brainfuck
---------

مقالهٔ اصلی: brainfuck

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

```

سی
--

مقالهٔ اصلی: سی (زبان برنامه‌نویسی)

```
#include <stdio.h>
void main()
{
 printf("Hello World!");
}

```

سی++
----

مقالهٔ اصلی: سی++

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

```

سی شارپ
-------

مقالهٔ اصلی: سی‌شارپ

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

```

Casio BASIC
-----------

مقالهٔ اصلی: کاسیو بیسیک

```
"HELLO, WORLD!"

```

Common Intermediate Language
----------------------------

مقالهٔ اصلی: 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)
---------------------------------

مقاله‌های اصلی: ColdFusion Markup Language و ColdFusion
CF Script:

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

```

CFML Tags:

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

```

کلوژر
-----

مقالهٔ اصلی: کلوژر
نسخه ی پیشانه ای (کنسولی):

```
(println "Hello, world!")

```

نسخه ی gui:

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

```

کوبول
-----

مقالهٔ اصلی: کوبول

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

```

دی
--

مقالهٔ اصلی: دی (زبان برنامه‌نویسی)

```
import std.stdio;

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

```

دارت
----

مقالهٔ اصلی: دارت (زبان برنامه‌نویسی)

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

```

DCL
---

مقالهٔ اصلی: DIGITAL Command Language
```
WRITE SYS$OUTPUT "Hello, world!"

```

دلفی
----

مقالهٔ اصلی: دلفی

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

```

Erlang
------

مقالهٔ اصلی: Erlang (programming language)

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

```

F
-

مقالهٔ اصلی: F Sharp (programming language)

```
printfn "Hello, world!"

```

Falcon
------

مقالهٔ اصلی: Falcon (programming language)

```
 printl("Hello, world!")
```

or

```
> "Hello, world!"
```

Forth
-----

مقالهٔ اصلی: Forth (programming language)

```
." Hello, world! "

```

فورترن
------

مقالهٔ اصلی: فورترن
(Fortran 95 and later)

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

```

(Fortran 90)

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

```

OR (FORTRAN 77 and prior)

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

```

Game Maker Language
-------------------

مقالهٔ اصلی: Game Maker Language

```
str='Hello, world!'

//Using the show_message() function:
show_message(str);

//Using the draw_text() function:
draw_text(0,0,str);
```

Go
--

مقالهٔ اصلی: Go (programming language)

```
package main

import "fmt"

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

```

Groovy
------

مقالهٔ اصلی: Groovy (programming language)

```
println "Hello, world!"

```

Haskell
-------

مقالهٔ اصلی: Haskell (programming language)

```
main = putStrLn "Hello, world!"

```

HOP
---

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

```

اچ‌تی‌ام‌ال
-----------

مقالهٔ اصلی: اچ‌تی‌ام‌ال

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

```

IDL
---

مقالهٔ اصلی: IDL (programming language)

```
print, "Hello, world!"
end

```

Io
--

مقالهٔ اصلی: Io (programming language)

```
 "Hello, world!" println

```

ISLISP
------

مقالهٔ اصلی: ISLISP

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

```

جی
--

مقالهٔ اصلی: J (programming language)

```
 'Hello, world!'
```

جاوا
----

مقالهٔ اصلی: جاوا (زبان برنامه‌نویسی)

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

```

جاوااسکریپت
-----------

مقالهٔ اصلی: جاوااسکریپت
To write to an HTML document:

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

```

To display an alert dialog box:

```
alert('Hello, world!');

```

To write to a console/debugging log:

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

```

Using Mozilla's Rhino:

```
print('Hello, world!');

```

Using Windows Script Host:

```
WScript.Echo("Hello, world!");

```

Kotlin
------

مقالهٔ اصلی: Kotlin (programming language)

```
package hello

fun main(args: Array<String>) {
 println("Hello, world!")
}

```

لیسپ
----

مقالهٔ اصلی: لیسپ

```
(princ "Hello, world!")

```

Logo
----

مقالهٔ اصلی: Logo (programming language)

```
print [Hello, world!]

```

لوآ
---

مقالهٔ اصلی: لوآ

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

```

M4
--

مقالهٔ اصلی: M4 (computer language)
```
Hello, world!
```

Malbolge
--------

مقالهٔ اصلی: Malbolge
```
(=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8dc
```

Mathematica
-----------

مقالهٔ اصلی: Mathematica

```
Print["Hello, world!"]

```

Maple
-----

مقالهٔ اصلی: Maple (software)

```
print(`Hello, world!`);

```

متلب
----

مقالهٔ اصلی: متلب

```
disp('Hello, world!')

```

mIRC Script
-----------

مقالهٔ اصلی: mIRC scripting language

```
echo -a Hello, world!
```

MUMPS
-----

مقالهٔ اصلی: MUMPS

```
main()
 write "Hello, world!"
 quit

```

Oberon
------

مقالهٔ اصلی: Oberon programming language
```
MODULE Hello;
  IMPORT Out;
BEGIN
  Out.String("Hello, world!");
  Out.Ln
END Hello.

```

Obix
----

مقالهٔ اصلی: Obix programming language
```
system.console.write_line ("Hello, world!")
```

Objective-C
-----------

مقالهٔ اصلی: Objective-C

```
# import <stdio.h>

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

```

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

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

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

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

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

```

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

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

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

```

Modern (llvm, ARC memory management):

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

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

```

OCaml
-----

مقالهٔ اصلی: OCaml

```
 print\_endline "Hello, world!"

```

Opa
---

مقالهٔ اصلی: Opa (programming language)
A "hello world" سرور وب:

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

```

Oriel
-----

مقالهٔ اصلی: Oriel (scripting language)
```
MessageBox(OK, 1, INFORMATION, "Hello, world!", "Oriel Says Hello", ResponseValue)
```

پاسکال
------

مقالهٔ اصلی: پاسکال (زبان برنامه‌نویسی)

```
program HelloWorld;
uses crt;

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

```

Pawn
----

مقالهٔ اصلی: Pawn (scripting language)

```
main()
{
    print("Hello, world.");
}

```

Perl 5
------

مقالهٔ اصلی: Perl

```
print "Hello, world!";

```

Or

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

```

پی‌اچ‌پی
--------

مقالهٔ اصلی: پی‌اچ‌پی

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

```

or

```
<?php print 'Hello, world' ?>

```

or

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

```

PL/SQL
------

مقالهٔ اصلی: PL/SQL

```
SET SERVEROUTPUT ON;
BEGIN
 DBMS\_OUTPUT.PUT\_LINE('Hello, world!');
END;

```

PowerShell
----------

مقالهٔ اصلی: Windows PowerShell

```
Write-Host "Hello, world!"

```

Prolog
------

مقالهٔ اصلی: Prolog

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

```

پایتون ۲
--------

مقالهٔ اصلی: پایتون (زبان برنامه‌نویسی)

```
print "Hello, world!"

```

پایتون ۳
--------

مقالهٔ اصلی: پایتون (زبان برنامه‌نویسی)

```
print("Hello, world!")

```

Pythonect
---------

مقالهٔ اصلی: Pythonect (programming language)

```
"Hello, world!" -> print

```

R
-

مقالهٔ اصلی: R (programming language)
```
cat('Hello, world!\n')

```

Racket
------

مقالهٔ اصلی: 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" سرور وب using Racket's `web-server/insta` language:

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

```

REXX
----

مقالهٔ اصلی: REXX
```
say Hello, world!

```

RPL
---

مقالهٔ اصلی: RPL (programming language)

```
<<"Hello, world!" MSGBOX>>

```

RTL/2
-----

مقالهٔ اصلی: 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;
```

روبی
----

مقالهٔ اصلی: روبی (زبان برنامه‌نویسی)

```
puts "Hello, world!"

```
یا بدون پرش به سر خط:

```
print "Hello, world!"

```

Rust
----

مقالهٔ اصلی: راست (زبان برنامه‌نویسی)

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

```

Scala
-----

مقالهٔ اصلی: Scala (programming language)

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

```

Scheme
------

مقالهٔ اصلی: Scheme (programming language)

```
(display "Hello, world!")

```

Shell
-----

مقالهٔ اصلی: Bourne shell

```
echo Hello, world!

```

Simula
------

مقالهٔ اصلی: Simula
```
Begin
 OutText ("Hello, world!");
 Outimage;
End;
```

Smalltalk
---------

مقالهٔ اصلی: Smalltalk

```
Transcript show: 'Hello, world!'.

```

SNOBOL
------

مقالهٔ اصلی: SNOBOL
```
  OUTPUT = 'Hello, world!'
END

```

Speakeasy
---------

مقالهٔ اصلی: Speakeasy (computational environment)
به صورت عبارات تعاملی(interactive):

```
"Hello, world!"
```
به عنوان برنامه:

```
program hello
  "Hello, world!"
end
```

SQL
---

مقالهٔ اصلی: 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!' -- This will work in SQL Server.

```

Smalltalk
---------

مقالهٔ اصلی: Smalltalk

```
Transcript show: 'Hello, world!'.

```

Stata
-----

مقالهٔ اصلی: Stata

```
display "Hello, world!"

```

Tcl
---

مقالهٔ اصلی: Tcl

```
puts "Hello, world!"

```

TI-BASIC
--------

مقالهٔ اصلی: TI-BASIC
```
Disp "Hello, world!"

```

UnrealScript
------------

مقالهٔ اصلی: UnrealScript
```
Log("Hello, world!");
```

Vala
----

مقالهٔ اصلی: Vala (programming language)

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

```

Visual Basic
------------

مقالهٔ اصلی: Visual Basic

```
 MsgBox "Hello, world!"

```

Visual Basic.NET
----------------

مقالهٔ اصلی: Visual Basic.NET

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

'non-console example:
Class Form1
 Public Sub Form1\_Load(ByVal sender As Object, ByVal e As EventArgs) Handles Me.Load()
 MsgBox("Hello, world!")
 End Sub
End Class

```

Whitespace
----------

مقالهٔ اصلی: Whitespace (programming language)

```
S S S T S S T S S S L
T L
S S S S S T T S S T S T L
T L
S S S S S T T S T T S S L
T L
S S S S S T T S T T S S L
T L
S S S S S T T S T T T T L
T L
S S S S S T S T T S S L
T L
S S S S S T S S S S S L
T L
S S S S S T T T S T T T L
T L
S S S S S T T S T T T T L
T L
S S S S S T T T S S T S L
T L
S S S S S T T S T T S S L
T L
S S S S S T T S S T S S L
T L
S S S S S T S S S S T L
T L
S S L
L
L

```

پیوند به بیرون
--------------

* Nodewave's computer language comparison, examples implementing the same loop algorithm *I will not throw paper airplanes in class*.
* Rosetta Code hello world listing, hello world examples for 230 programming languages.