Proqramlaşdırma dilini yeni öyrənməyə başlayarkən ilk yazılan proqram adətən "Salam Dünya" proqramı olur. Bir çox dildə yazılmış Salam Dünya proqram nümunələri:

3D Games Creator
----------------

```
print "Salam Dünya"
wait key

```

ABAP
----

```
REPORT Z\_HALLO\_WELT.
WRITE 'Salam Dünya!'.

```

ActionScript
------------

```
trace('Salam Dünya');

```

Ada
---

```
with Ada.Text\_IO;
procedure Salam is
begin
 Ada.Text\_IO.Put\_Line ("Salam Dünya!");
end Hallo;

```

ALGOL 60
--------

```
 'BEGIN'
     OUTSTRING(2,'('Salam Dünya')');
 'END'
```

ALGOL 68
--------

```
 ( print("Salam Dünya!") )
```

AMOS BASIC
----------

```
? "Salam Dünya!"
```

AppleScript
-----------

```
display dialog "Salam Dünya"

```

ASP (Active Server Pages)
-------------------------

```
<%
  Response.Write("Salam Dünya!")
%>
```

və ya

```
<%="Salam Dünya!"%>
```

AutoHotkey
----------

```
MsgBox Salam Dünya!

```

AutoIt
------

```
MsgBox(0, "", "Salam Dünya!")

```

AutoLISP
--------

```
(princ "Salam Dünya!")

```

awk
---

```
BEGIN { print "Salam Dünya!" }

```

B
-

```
main() {
 printf("Salam Dünya!");
}

```

BASIC
-----

```
10 PRINT "Salam Dünya!"

```

Batch
-----

```
@echo Salam Dünya!
```

BeanShell
---------

```
print("Salam Dünya!");

```

Blitz Max
---------

```
Framework BRL.StandardIO
Print("Salam Dünya!")

```

Boo
---

```
print "Salam Dünya!"

```

C/AL
----

```
MESSAGE('Salam Dünya')

```

C
-

```
#include <stdio.h>

int main(void)
{
 puts("Salam Dünya!");
}

```

### C GTK ilə

```
/\*
 \* "gcc hello\_world.c -o hello\_world `pkg-config --cflags --libs gtk+-2.0`" şəklində kompilyasiya edin. 
 \* 
 \*/
#include <gtk/gtk.h>
gboolean delete\_event(GtkWidget \*widget, GdkEvent \*event, gpointer data) {
 return FALSE;
}
void destroy(GtkWidget \*widget, gpointer data) {
 gtk\_main\_quit();
}
void clicked(GtkWidget \*widget, gpointer data) {
 g\_print("Salam Dünya!\n");
}
int main (int argc, char \*argv[]) {
 gtk\_init(&argc, &argv);
 GtkWidget \*window;
 GtkWidget \*button;
 window = gtk\_window\_new(GTK\_WINDOW\_TOPLEVEL);
 gtk\_container\_set\_border\_width(GTK\_CONTAINER(window), 10);
 g\_signal\_connect(G\_OBJECT(window), "delete-event", G\_CALLBACK(delete\_event), NULL);
 g\_signal\_connect(G\_OBJECT(window), "destroy", G\_CALLBACK(destroy), NULL);
 button = gtk\_button\_new\_with\_label("Salam Dünya!");
 g\_signal\_connect(G\_OBJECT(button), "clicked", G\_CALLBACK(clicked), NULL);
 gtk\_widget\_show(button);
 gtk\_container\_add(GTK\_CONTAINER(window), button);
 gtk\_widget\_show(window);
 gtk\_main();
 return 0;
}

```

### C Windows API ilə

```
#include <windows.h>
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
 MessageBox(0, "Salam Dünya!", "Mənim birinci proqramım", MB\_OK);
 return 0;
}

```

C++
---

```
#include <iostream>
int main()
{
 std::cout << "Salam Dünya!" << std::endl;
}

```

### C++/CLI

```
int main()
{
 System::Console::WriteLine("Salam Dünya!");
}

=== [[C++]] [[gtkmm]] ilə ===
<syntaxhighlight lang="cpp" highlight="10">
#include <gtkmm/main.h>
#include <gtkmm/button.h>
#include <gtkmm/window.h>
int main (int argc, char\* argv[])
{
 Gtk::Main m\_main(argc, argv);
 Gtk::Window m\_window;
 Gtk::Button m\_button("Salam Dünya!");
 m\_window.add(m\_button);
 m\_button.show();
 Gtk::Main::run(m\_window);
 return 0;
}

```

### C++ Qt kitabxanası ilə

```
#include <QLabel>
#include <QApplication>
int main(int argc, char\* argv[])
{
 QApplication app(argc, argv);
 QLabel label("Salam Dünya!");
 label.show();
 return app.exec();
}

```

C#
--

```
class MainClass
{
 public static void Main()
 {
 System.Console.WriteLine("Salam Dünya!");
 }
}

```

CIL
---

```
.assembly SalamDunya { }
.assembly extern mscorlib { }
.method public static void Main() cil managed
{
    .entrypoint
    .maxstack 1
    ldstr "Salam Dünya!"
    call void [mscorlib]System.Console::WriteLine(string)
    ret
}
```

CLIST
-----

```
WRITE Salam Dünya

```

Clojure
-------

```
(println "Salam Dünya!")

```

CLP
---

```
PGM
SNDPGMMSG MSG('Salam Dünya!') MSGTYPE(\*COMP)
ENDPGM

```

COBOL
-----

```
000100 IDENTIFICATION DIVISION.
000200 PROGRAM-ID. HELLOWORLD.
000900 PROCEDURE DIVISION.
001000 MAIN.
001100 DISPLAY "Salam Dünya!".
001200 STOP RUN.

```

COLDFUSION
----------

```
<cfset beispiel = "Salam Dünya!" >
<cfoutput>#beispiel#</cfoutput>

```

COMAL
-----

```
10 PRINT "Salam Dünya!"

```

Common Lisp
-----------

```
(write-line "Salam Dünya!")

```

Component Pascal
----------------

```
MODULE SalamDunya;
IMPORT Out;
PROCEDURE Output\*;
BEGIN
 Out.String ("Salam Dünya!");
 Out.Ln;
END Output;
END HalloWelt.

```

D
-

```
import std.stdio;
void main() {
 writeln("Salam Dünya!");
}

```

dBase/Foxpro
------------

```
? "Salam Dünya!"
```

Object Pascal
-------------

komanda interfeysi:

```
program SalamDunya;
begin
 writeln('Salam Dünya!');
end.

```

qrafik interfeys:

```
 program HalloWelt;
 {$APPTYPE GUI}
 uses Dialogs;
 begin
 ShowMessage('Salam Dünya!');
 end.

```

Eiffel
------

```
class Salam\_Dunya
create
 make
feature
 make is
 do
 io.put\_string("Salam Dünya!%N")
 end
end

```

ELAN
----

```
putline ("Salam Dünya!");

```

Emacs Lisp
----------

```
(print "Salam Dünya!")

```

Erlang
------

```
-module(Salam).
-export([Salam\_Dunya/0]).

Salam\_Dunya() -> io:fwrite("Salam Dünya!\n").

```

F#
--

```
printfn "Salam Dünya"

```

Forth
-----

```
.( Salam Dünya!)

```

Fortran
-------

```
program salam
write(\*,\*) "Salam Dünya!"
end program salam

```

FreeBASIC
---------

```
print "Salam Dünya!"
```

GML
---

```
show_message("Salam Dünya!");
```

Gambas
------

```
    PUBLIC SUB Form_Enter()
    PRINT "Salam Dünya!"
    END
```

Go
--

```
package main

import "fmt"

func main() {
 fmt.Println("Salam Dünya!")
}

```

Groovy
------

```
println "Salam Dünya!"

```

Haskell
-------

```
main :: IO ()
main = putStrLn "Salam Dünya!"

```

Haxe
----

```
class Test {
 static function main() {
 trace("Salam Dünya!");
 }
}

```

IDL (RSI)
---------

```
PRO salam_dunya
 PRINT, "Salam Dünya!"
END

```

Io
--

```
"Salam Dünya!" print

```

J#
--

```
public class HalloWelt
{
 public static void main(String[] args)
 {
 System.Console.WriteLine("Salam Dünya!");
 }
}

```

JavaScript
----------

```
document.write("Salam Dünya!");

```

Java
----

```
class Hallo {
 public static void main( String[] args ) {
 System.out.println("Salam Dünya!");
 }
}

```

və ya

```
import javax.swing.\*;
class Salam {
 public static void main( String[] args ) {
 JOptionPane.showMessageDialog( null, "Salam Dünya!" );
 }
}

```

KiXtart
-------

```
? "Salam Dünya!"
```

LaTeX
-----

```
\documentclass{article}
\begin{document}
Salam Dünya!
\end{document}

```

LISP
----

```
(print "Salam Dünya!")

```

Logo
----

```
print [Salam Dünya!]

```

Lua
---

```
print ("Salam Dünya!")

```

MATLAB
------

```
fprintf('Salam Dünya!');

```

və ya

```
disp('Salam Dünya!');

```

və ya

```
disp Salam\_Dünya

```

və ya

```
'Salam Dünya'

```

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

```
on 1:load:*: { echo Salam Dünya! }
```

Oberon
------

```
MODULE SalamDunya;
IMPORT Write;
BEGIN
    Write.Line("Salam Dünya!");
END HalloWelt.
```

OCaml
-----

```
print\_endline "Salam Dünya!";;

```

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

```
#import <stdio.h>
int main()
{
 puts("Salam Dünya!");
 return 0;
}

```

### Objective-C Cocoa ilə

```
#import <Cocoa/Cocoa.h>
@interface Controller : NSObject
{
 NSWindow \*window;
 NSTextField \*textField;
}
@end
int main(int argc, const char \*argv[])
{
 NSAutoreleasePool \*pool = [[NSAutoreleasePool alloc] init];
 NSApp = [NSApplication sharedApplication];
 Controller \*controller = [[Controller alloc] init];
 [NSApp run];
 [controller release];
 [NSApp release];
 [pool release];
 return EXIT\_SUCCESS;
}
@implementation Controller
- (id)init
{
 if ((self = [super init]) != nil) {
 textField = [[NSTextField alloc] initWithFrame:NSMakeRect(10.0, 10.0, 85.0, 20.0)];
 [textField setEditable:NO];
 [textField setStringValue:@"Salam Dünya!"];

 window = [[NSWindow alloc] initWithContentRect:NSMakeRect(100.0, 350.0, 200.0, 40.0)
 styleMask:NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask
 backing:NSBackingStoreBuffered
 defer:YES];
 [window setDelegate:self];
 [window setTitle:@"Salam Dünya!"];
 [[window contentView] addSubview:textField];
 [window makeKeyAndOrderFront:nil];
 }

 return self;
}
- (void)windowWillClose:(NSNotification \*)notification
{
 [NSApp terminate:self];
}

@end

```

OpenLaszlo
----------

```
<canvas>
 <text>Salam Dünya!</text>
</canvas>

```

Oz
--

```
{Show 'Salam Dünya'}
```

Pascal
------

```
program Hallo ( output );
begin
 writeln('Salam Dünya!');
end.

```

PAWN
----

```
main()
{
 printf("Salam Dünya!\n");
}

```

PEARL
-----

```
MODULE (HALLOWELT);
 SYSTEM;
 TERMINAL:DIS<->SDVLS(2);

 PROBLEM;
 SPC TERMINAL DATION OUT ALPHIC DIM(,) TFU MAX FORWARD CONTROL (ALL);

 MAIN:TASK;
 OPEN TERMINAL;
 PUT 'Hallo Welt!' TO TERMINAL;
 CLOSE TERMINAL;
 END;

MODEND;

```

Perl
----

```
print "Salam Dünya!\n";

```

PHP
---

```
<?php
    print "Salam Dünya!";
?>
```

və ya:

```
<?php
    echo "Salam Dünya!";
?>
```

və ya:

```
<?="Salam Dünya!"?>
```

Pike
----

```
int main() {
 write("Salam Dünya!\n");
 return 0;
}

```

PL/I
----

```
 Test: procedure options(main);
    put skip list("Salam Dünya!");
 end Test;
```

PocketC
-------

Konsole:

```
main() {
 puts("Salam Dünya!");
}

```

POV-Ray
-------

```
camera {
 location <0, 0, -5>
 look_at  <0, 0, 0>
}
light_source {
 <10, 20, -10>
 color rgb 1
}
light_source {
 <-10, 20, -10>
 color rgb 1
}
background {
 color rgb 1
}
text {
 ttf "someFont.ttf"
 "Salam Dünya!", 0.015, 0
 pigment {
   color rgb <0, 0, 1>
 }
 translate -3*x
}
```

PowerShell
----------

```
"Salam Dünya!"

```

və ya:

```
echo "Salam Dünya!"

```

və ya:

```
[System.Console]::WriteLine("Salam Dünya!")

```

Progress 4GL
------------

```
 DISPLAY "Salam Dünya!".

```

oder:

```
 MESSAGE "Salam Dünya!"
 VIEW-AS ALERT-BOX INFO BUTTONS OK.

```

Prolog dili
-----------

```
 ?- write('Salam Dünya!'), nl.

```

PureBasic
---------

```
 OpenConsole()
   Print("Salam Dünya!")
   Input() ;Beendet das Programm beim nächsten Tastendruck
 CloseConsole()
```

Python
------

python 3-cü versiyaya qədər:

```
print "Salam Dünya!"

```

pyton 3-cü versiyadan sonra (3-cü versiya daxil olmaqla):

```
print("Salam Dünya")

```

QBASIC
------

```
PRINT "Salam Dünya!"

```

R
-

```
print ("Salam Dünya!")

```

və ya

```
cat ("Salam Dünya!\n")

```

REXX
----

```
say "Salam Dünya!"

```

Ruby
----

```
puts "Salam Dünya!"

```

### Ruby GTK+ ilə

```
require "gtk2"
Gtk::Window.new("Salam Dünya!").show\_all.signal\_connect(:delete\_event){Gtk.main\_quit}
Gtk.main

```

### Ruby Tk ilə

```
require "tk"
TkRoot.new{ title "Salam Dünya!" }
Tk.mainloop

```

SAC (Single Assignment C)
-------------------------

```
use StdIO: all;
int main()
{
 printf("Salam Dünya!\n");
 return(0);
}

```

SAS
---

```
data \_null\_;
 put "Salam Dünya!";
run;

```

Scala
-----

```
object HalloWelt extends Application {
 println("Salam Dünya!")
}

```

Scheme
------

```
(display "Salam Dünya!")
(newline)

```

Smalltalk
---------

```
'Salam Dünya!' out.

```

Spec#
-----

```
 using System;
 public class Programm
 {
 public static void Main(string![]! args)
 requires forall{int i in (0:args.Length); args[i] != null};
 {
 Console.WriteLine("Salam Dünya!");
 }
 }

```

Standard ML
-----------

```
print "Salam Dünya!\n"

```

SPL
---

```
debug "Salam Dünya!";

```

SQL
---

```
SELECT 'Salam Dünya' AS message;

```

Oracle və MySQL üçün:

```
SELECT 'Salam Dünya!' FROM dual;

```

IBM-DB2 üçün:

```
SELECT 'Salam Dünya!' FROM sysibm.sysdummy1;

```

MSSQL, MySQL, PostgreSQL üçün:

```
SELECT 'Salam Dünya!';

```

StarOffice Basic
----------------

```
 sub main
 print "Salam Dünya!"
 end sub

```

və ya:

```
 sub HalloWeltAlternativ
 MsgBox "Salam Dünya!"
 end sub

```

Tcl
---

```
puts "Salam Dünya!"

```

Tcl/Tk
------

```
label .l -text "Salam Dünya"
pack .l

```

TeX
---

```
Salam, Dunya!\bye

```

XOTcl
-----

```
proc hello {
puts "Salam Dünya!"
}

```

Turing
------

```
put "Salam Dünya!"

```

Unix-Shell
----------

```
echo 'Salam Dünya!'

```

Verilog
-------

```
module salam\_dunya;
initial begin
 $display ("Salam Dünya!");
 #10 $finish;
end
endmodule

```

VHDL
----

```
entity HelloWorld is
end entity HelloWorld;
architecture Bhv of HelloWorld is
begin
 HelloWorldProc: process is
 begin
 report "Salam Dünya!";
 wait;
 end process HelloWorldProc;
end architecture Bhv;

```

VBScript
--------

```
    MsgBox "Salam Dünya!"
```

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

Konsoldan:

```
Module Module1
 Sub Main()
 Console.WriteLine("Salam Dünya!")
 End Sub
End Module

```

Qrafik interfeyslə:

```
Class Salam
 Sub SalamDunya
 MsgBox("Salam Dünya")
 End Sub
End Class

```

XUL
---

```
<?xml version="1.0"?>
<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
<label value="Salam Dünya!"/>
</window>

```

XAML
----

```
<?Mapping ClrNamespace="System" Assembly="mscorlib"
 xmlNamespace="http://www.gotdotnet.com/team/dbox/mscorlib/System" ?>
<Object xmlns="http://www.gotdotnet.com/team/dbox/mscorlib/System"
 xmlns:def="Definition" def:Class="MyApp.Hello">
 <def:Code>
 <![CDATA[
 Shared Sub Main()
 '{
 System.Console.WriteLine("Salam Dünya!")' ;
 '}
 End Sub
 ]]>
 </def:Code>
</Object>

```

Həmçinin bax
------------

İstinadlar
----------

Xarici keçidlər
---------------