Hello World

Pour les articles homonymes, voir Hello (homonymie).

hello world (traduit littéralement en français par « bonjour le monde ») sont les mots traditionnellement écrits par un programme informatique simple dont le but est de faire la démonstration rapide d'un langage de programmation (par exemple à but pédagogique) ou le test d'un compilateur.

Certains des programmes imprimant ces mots sont étonnamment complexes, particulièrement dans un contexte d'interface graphique. D'autres sont très simples, particulièrement ceux qui utilisent un interpréteur de ligne de commande pour afficher le résultat. Dans plusieurs systèmes embarqués, le texte peut être envoyé sur une ou deux lignes d'un afficheur LCD (ou dans d'autres systèmes, une simple DEL peut se substituer à un hello world).

Histoire

Alors que les petits programmes de test existaient depuis le début de la programmation, la tradition d'utiliser hello world comme message de test a été initiée par le livre The C Programming Language de Brian Kernighan et Dennis Ritchie. Le premier exemple de ce livre affiche hello, world (sans majuscule ni point final, mais avec une virgule et un retour à la ligne final). Le premier hello world dont Ritchie et Kernighan se souviennent provient d'un manuel d'apprentissage du langage B écrit par Kernighan^[1].

Au XXI^e siècle, les programmes affichent plus souvent Hello world! comme une phrase, avec majuscule et point d'exclamation final.

Le programme Hello world! suivant les langages

ABC

 WRITE "Hello world!"

ActionScript 3.0

 trace("Hello world!");

var champ:TextField = new TextField();
champ.text = "Hello World !";
this.addChild(champ);

Ada

 with Ada.Text_IO;
 use Ada.Text_IO;
 
 procedure Bonjour is
 begin -- Bonjour
   Put("Hello world!");
 end Bonjour;

Alma

Hello world!

AmigaE

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

APL

 'Hello world!'

AppleScript

 display dialog "Hello world!"

ASP et ASP.NET

 <%
 Response.Write("Hello World")
 %>

AspectJ

Main.java:
 
    public class Main {
        public static void main(String[] args){
        }
    }
 
HelloWorld.aj:
 
    public aspect HelloWorld {
        pointcut mainCall() : call(public static void *.main(String[] args));
 
        before() : mainCall() {
            System.out.println( "Hello world!" );
        }
    }

Assembleur de Bytecode Java

Ce code fonctionne avec les assembleurs Jasmin et Oolong.

    .class public Hello
    .super java/lang/Object
 
    ; spécification du constructeur par défaut
    .method public <init>();
        ; pousse la référence à l'objet courant sur la pile
        aload_0 
        ; appel statiquement lié aux constructeurs de la classe de base
        invokespecial java/lang/Object/<init>()V
        return
    .end method
 
    .method public static main([java/lang/String;)V
       .limit stack 2
       ; pousse la réf. à l'objet statique out de la classe System sur la pile
       getstatic java/lang/System/out Ljava/io/PrintStream
       ; pousse la chaîne de caractère sur la pile
       ldc "Hello world!" 
       ; appel polymorphe
       invokevirtual java/io/PrintStream/println(Ljava.lang.String;)V
       return
    .end method

Assembleur x86 sous DOS

 cseg segment
 assume cs:cseg, ds:cseg
 org 100h	
 main proc	
 jmp debut
 mess db 'Hello world!$'
 debut:
 mov dx, offset mess
 mov ah, 9
 int 21h
 ret
 main endp	
 cseg ends
 end main

Assembleur x86, écrit pour l'assembleur TASM sous DOS

 .model small
 
 .stack 100h
 
 .data
    bonjour  db  "Hello world!$"
 
 .code
    main  proc
        mov  AX,@data
        mov  DS, AX
        mov  DX, offset bonjour
        mov  AX,0900h
        int  21h
        mov  AX,4C00h
        int  21h
        main endp
    end main

Assembleur x86, sous Linux, écrit pour l'assembleur NASM

 section .data
        helloMsg:     db 'Hello world!',10 
        helloSize:    equ $-helloMsg
 section .text
        global _start
 _start:
        mov eax,4             ; Appel système "write" (sys_write)
        mov ebx,1             ; File descriptor, 1 pour STDOUT (sortie standard)
        mov ecx, helloMsg     ; Adresse de la chaîne a afficher
        mov edx, helloSize    ; Taille de la chaîne
        int 80h               ; Execution de l'appel système
                              ; Sortie du programme
        mov eax,1             ; Appel système "exit"
        mov ebx,0             ; Code de retour
        int 80h

Assembleur x86 écrit pour l'assembleur FASM

org 100h
mov dx, message
mov ah, 09h
int 21h
 
; les quatre lignes suivantes servent à attendre qu'une touche soit frappée avant de quitter le programme normalement
; elles peuvent donc être exclues du programme, à ceci près que la visualisation du résultat sera impossible, la fenêtre de console
; se refermant trop vite
xor ah, ah
int 16h
mov ax, 4c00h
int 21h
 
message db "Hello world!$"

Assembleur x86 écrit pour l'assembleur MASM

.386
.MODEL flat, stdcall
OPTION CASEMAP: none
 
Include kernel32.inc
Include masm32.inc
 
Includelib kernel32.lib
Includelib masm32.lib
 
.data													
HelloWorld  db   "Hello World!"	, 0
 
.data?
WaitBufer   db 10 dup(?)
 
.code							
Start :
invoke StdOut, addr HelloWorld
invoke StdIn, addr WaitBufer, 1
invoke ExitProcess, 0
 
End Start

Awk

#!/usr/bin/awk -f
 BEGIN { print "Hello world!" }

BASIC

10 PRINT "Hello world!"
20 END 'A noter que le END n est pas nécesaire

Noter que les étiquettes (numéros devant les lignes) ne sont plus nécessaires dans les versions modernes (BBC BASIC for Windows, Quick Basic, Turbo Basic, QBasic, Visual Basic...). Elles ne sont plus utilisées que pour les instructions de contrôle de flux (les boucles et les sauts, notamment le GOTO et le GOSUB).

Bash

#!/bin/bash
echo 'Hello world'

BCPL

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

Befunge

<q_,#! #:<"Hello world!"a

Brainfuck

préparation
++++++++++[>+++++++>++++++++++>+++>+<<<<-]
écrit "Hello "
>++. >+. +++++++. . +++. >++.
écrit "World!" et passe à la ligne
<<+++++++++++++++. >. +++. ------. --------. >+. >.

C

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

Ou :

#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    puts("Hello World!");
 
    return EXIT_SUCCESS;
}

En utilisant uniquement des fonctions POSIX :

#include <unistd.h>
 
int main(void)
{
	write(1, "Hello world!\n", 13);
	return 0;
}

C (uniquement sous windows, API Win32)

#include <windows.h>
 
int WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow )
{
    MessageBox( NULL, TEXT ("Hello world!\n"), TEXT (""), MB_OK );
    return 0;
}

C (uniquement sur PSP)

#include <pspkernel.h>
#include <pspdebug.h>
 
PSP_MODULE_INFO("Hello World", 0, 1, 1);
#define printf pspDebugScreenPrintf 
 
/* Exit callback */
int exit_callback(int arg1, int arg2, void *common)
{
    sceKernelExitGame();
    return 0;
}
 
/* Callback thread */
int CallbackThread(SceSize args, void *argp)
{
    int cbid;
 
    cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
    sceKernelRegisterExitCallback(cbid);
 
    sceKernelSleepThreadCB(); 
 
    return 0;
}
 
/* Sets up the callback thread and returns its thread id */
int SetupCallbacks(void)
{
    int thid = 0;
 
    thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
    if(thid >= 0) {
        sceKernelStartThread(thid, 0, 0);
    }
 
    return thid;
} 
 
int main()
{       
    pspDebugScreenInit();
    SetupCallbacks();
    printf("Hello, World");
    sceKernelSleepThread();
 
    return 0;
}

C# (en Console)

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

C# (Application Windows)

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

Voir windows Forms

C++

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

Caml

 print_endline "Hello world!";;

Ou

 (* Fichier hello.ml*)
 let hello () =
   print_string "Hello world!";
   print_newline();;
 let main () =
   hello();
   exit 0;;
 main();;

Casio (calculatrices graphiques de la gamme «Graph xx»)

 "Hello world!"

ou :

 Locate 1,1,"Hello world!"

ou encore :

Text 1,1,"Hello world!"

CIL

.method public static void Main() cil managed
{
    .entrypoint
    .maxstack 8
    ldstr "Hello world!."
    call void [mscorlib]System.Console::WriteLine(string)
    ret
}

Clean

module hello
 
Start :: String
Start = "Hello world!"

CLIST

PROC 0
WRITE Hello world!

COBOL

        IDENTIFICATION DIVISION.
        PROGRAM-ID. HELLO-WORLD.
 
        ENVIRONMENT DIVISION.
 
        DATA DIVISION.
 
        PROCEDURE DIVISION.
            DISPLAY "Hello world!".
            STOP RUN.

Dans les versions modernes du langage, le programme se simplifie ainsi (la suppression du point sur l'avant-dernière ligne n'est pas une innovation) :

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

Common Lisp

 (princ "Hello world!")

D

import std.stdio;
 
int main ()
{
    writefln("Hello world!");
    return 0;
}

Delphi

 unit Unit1;
 
 interface
 
 uses
   Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
   Dialogs;
 
 type
   TForm1 = class(TForm)
     procedure FormActivate(Sender: TObject);
   private
     { Private declarations }
   public
     { Public declarations }
  end;
 
 var
   Form1: TForm1;
 
 implementation
 
 {$R *.dfm}
 
 procedure TForm1.FormActivate(Sender: TObject);
 begin
   ShowMessage('Hello world');
 end;
 
 end.

ou en console :

program hello_world;
 
{$APPTYPE CONSOLE}
 
uses
  SysUtils;
 
begin
  writeln('Hello world!');
  readln;
end.

Dialog/Xdialog

dialog --title 'Hello world!' --ok-label 'OK' --msgbox 'Hello world!' 0 0
Xdialog --title 'Hello world!' --ok-label 'OK' --msgbox 'Hello world!' 0 0
kdialog --title 'Hello world!'  --msgbox 'Hello world!' 0 0

DCL batch

$ write sys$output "Hello world!"

ed et ex (Ed extendu)

a
Hello world!
.
p

ou comme ceci:

echo -e 'a\nHello world!\n.\np'|ed
echo -e 'a\nHello world!\n.\np'|ex

Eiffel

class HELLO_WORLD
 
create
     execute
 
feature {NONE} -- Initialization
 
    execute is
         -- Execute Hello World !
         do
             io.put_string("Hello world!%N")
         end
 
end

Erlang

-module(hello).
-export([hello_world/0]).
 
hello_world() -> io:fwrite("Hello world!\n").

EUPHORIA

puts(1, "Hello world!")

Forte TOOL

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

." Hello world!" CR

Fortran (ANSI 77)

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

Frink

    println["Hello world!"]

Gambas

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

GML (Game Maker Language)

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

Gnuplot

 #! /usr/bin/gnuplot
 print "hello world"

GOTO++

   GOTOPRINTDUTEXTE() ; «Hello world!»

Grails

   class HelloWorldController {
        def index = {render "Hello, world!" }
   }

Graphviz

 echo "digraph G {Hello->World}" | dot -Tpng >hello.png

Groovy

    print "hello world"

Haskell

   module HelloWorld (main) where
 
   main = putStrLn "Hello world!"

Heron

 program HelloWorld;
 functions {
   _main() {
     String("Hello world!") |> GetStdOut();
   }
 }
 end

HP-41 et HP-42S

(calculatrice Hewlett-Packard alphanumérique)

 
   01 LBLTHELLO
   02 THELLO, WORLD
   03 PROMPT 

HP-40 G

(calculatrice Hewlett-Packard)

DISP 1;"HELLO WORLD !":
FREEZE:

HTML

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
	"http://www.w3.org/TR/html4/strict.dtd">
 
<html lang="fr">
	<head>
		<meta http-equiv="content-type" content="text/html; charset=utf-8">
		<title>Afficher «Hello world»</title>
	</head>
 
	<body>
		<p>Hello World</p>
	</body>
</html>

XHTML 1.0 Strict

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr">
	<head>
		<meta http-equiv="content-type" content="text/html; charset=utf-8" />
		<title>Afficher «Hello world» en XHTML 1.0 Strict</title>
	</head>
 
	<body>
		<p>Hello world!</p>
	</body>
</html>

ICON

   procedure main()
     write("Hello World !")
   end

Inform 7

"Hello World" by "Anonymous"
 
Earth is a room. The description of Earth is "Hello World!"
 
When play begins:
	say "Bonjour tout le monde !"

Iptscrae

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

Io

    "Hello world!" print

ou

    write("Hello world!\n")

Java

/* Affichage console */
class HelloWorld {
    public static void main(String[] args) {
        System.out.print("Hello world!"); 
    }
}

ou

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

JavaScript / HTML DOM

En javascript :

document.write("Hello world!");

Cela peut être inclus dans du HTML de cette manière :

<script type="text/javascript">
 	document.write("Hello world!");
 </script>

Ou par l'appel à une fonction :

 <script type="text/javascript">
alert("Hello world!");
 </script>

Kogut

    WriteLine "Hello world!"

Langage machine (écrit en hexadécimal)

Pour x86, obtenu par compilation d'assembleur FASM

BA1001B409CD2130E4CD16B8004CCD2148656C6C6F20576F726C642124

LaTeX

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

Lingo pour Director 8.5 et plus

   put "Hello world!"

ou

   mbtext = member(#text).new()
   mbtext.text = "Hello world!"

Linotte

Livre : HelloWorld
 Paragraphe : Affichage
 Les actions :
   "Hello, World !" !

Lisaac

section HEADER
  + name        := HELLO_WORLD;
  - category    := MACRO;
section INHERIT
  - parent_object:OBJECT := OBJECT;
section PUBLIC
  - make <-
  ( 
    "Hello world !\n".print;
  );

Lisp

    (write-line "Hello World!")

Logo

   print [Hello world!]

ou

   pr [Hello world!]

en mswlogo seulement

   messagebox [Hi] [Hello world!]

LOLCODE

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

Lua

    print("Hello world!")

Lua sur PSP

red = Color.new(255, 0, 0) --declaration de la couleur rouge
 
while true do --commencement de la boucle
screen:clear()--on efface l'ecran
screen.flip()--on actualise l'ecran
 
screen:print(00,10,"Hello World",red)--on affiche le texte "Hello World" en position {00;10}
screen.waitVblankStart()--on attend l'instruction suivante (dans ce cas la on laisse afficher le texte indefiniment)
 
screen.flip()--on actualise l'ecran
end --fin de la boucle

Malbolge

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

MATLAB

    disp('Hello world');

ou

    fprintf('Hello world\n');

METAFONT

message "Hello world!";
bye

mIRC Script

    echo -a Hello World!

M (MUMPS)

   W "Hello world!"

Modula-2

   MODULE Hello;
 
   FROM Terminal2 IMPORT WriteLn, WriteString;
 
   BEGIN
      WriteString("Hello world!");
      WriteLn;
   END Hello.

MS-DOS batch

Utilisé avec l'interpreteur standard command.com. Le symbole « @ » est optionnel et évite au système de répéter la commande avant de l'exécuter. Le symbole doit être enlevé avec les versions de MS-DOS antérieures au 5.0.

    @echo Hello world!
     pause

MUF

   : main
     me @ "Hello world!" notify
   ;
   

MXML

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

Objective C

#import <Foundation/Foundation.h>
 
    int main () 
{
       NSLog(@"Hello world!");
       return 0
}

Objective Caml

Cf. #Caml. Cet exemple vaut aussi pour le F#.

 print_endline "Hello world"

Octave

#!/usr/bin/octave
disp("hello world")

Ook

Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook! Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook? Ook! Ook.

OpenLaszlo

   
        <canvas>
            <text>Hello world</text>
        </canvas>
    

OPL

   PROC hello:
     PRINT "Hello world!"
   ENDP

OPS5

   (object-class request
            ^action)
 
   (startup
      (strategy MEA)
      (make request ^action hello)
   )
 
 
   (rule hello
      (request ^action hello)
      -->
        (write |Hello world!| (crlf))
   )

Oz

{Browse 'Hello world !'}

Pascal

 PROGRAM salutation;
begin 
     writeln('hello world');
end.

PDF

%PDF-1.3
1 0 obj
  << /Type /Catalog
     /Outlines 2 0 R
     /Pages 3 0 R
  >>
endobj

2 0 obj
  << /Type /Outlines
     /Count 0
  >>
endobj

3 0 obj
  << /Type /Pages
     /Kids [4 0 R]
     /Count 1
  >>
endobj

4 0 obj
  << /Type /Page
     /Parent 3 0 R
     /MediaBox [0 0 612 792]
     /Contents 5 0 R
     /Resources << /ProcSet 6 0 R
                   /Font << /F1 7 0 R >>
                >>
>>
endobj

5 0 obj
  << /Length 73 >>
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
0000000364 00000 n
0000000466 00000 n
0000000496 00000 n

trailer
  << /Size 8
     /Root 1 0 R
  >>
startxref
625
%%EOF

Perl

 #!/usr/bin/perl 
 print "Hello world!\n";

Perl 6 et 5.10

  say "Hello world";

PHP

<?php
 echo "Hello world!";
 
 // On peut aussi utiliser les guillemets simples
  echo 'Hello World!';
?>

ou

<?php
 print ("Hello world!");
?>

ou (version printf() du c)

<?php
printf("%s %s","Hello","world!");
?>

et encore (en version raccourcie)

<?="Hello world!"?>

Piet

Hello World en langage Piet

.
.
.
.
.
.
.
.
.
.
.
.
.

PlanFacile

#start{0}#message{Hello world !}

ou pour les amateurs d'IOCCC

#define{d}{r}#define{r}{H#2#1#H#define{r}{#1#1}}
#H{#h{#r{#r{#e}#define{H}{#l}}{e}}{#define{d}{# }!}
{#h{#l}{#o}{#w{w}}#e#define{h}{#3#define{o}{r}#1#2}
#w{d}{#d}#define{w}{#0}}#define{h}{#1#d#3#2}#define{e}
{l}}#start{0}#define{H}{#foot{#1#define{l}{o}}}

PL/I

hello: procedure options(main);
       display ('Hello world!');
       /* Ou, variante : put skip list ('Hello world!'); */
       end hello;

PL/SQL

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

PL/PGSQL

   CREATE FUNCTION hello_world() RETURNS VOID AS $$
   BEGIN
   	RAISE NOTICE 'Hello World';
   END
   $$ LANGUAGE 'plpgsql' VOLATILE;

POP-11

   'Hello world!' =>

POV-Ray

 #include "colors.inc"
 camera {
   location <3, 1, -10>
   look_at <3,0,0>
 }
 light_source { <500,500,-1000> White }
 text {
   ttf "timrom.ttf" "Hello world!" 1, 0
   pigment { White }
 }

Ce qui donnera

PostScript

%!PS
100 /Helvetica findfont exch scalefont setfont
10 300 moveto
(Hello, world !) show
showpage

PROC (langage de commande Pick)

001 PQ
002 C Affiche 'Hello, world !' à l'écran
003 OHello, world !
004 X

Prolog

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

Pseudo-code

output Hello world!

PureBasic

    OpenConsole()
    PrintN("Hello World!")

Python

    print "Hello world!"

ou depuis version 3.0:

    print("Hello world!")

Rebol

    print "Hello world!"

REXX, NetRexx, et Object REXX

   say "Hello world!"

ou:

   say 'Hello world!'

RPG

Syntaxe libre

      /FREE

          DSPLY 'Hello, world!';

          *InLR = *On;

      /END-FREE 

Syntaxe traditionnelle

Avec cette syntaxe, une constante doit être utilisée car seules les positions 12 à 25 peuvent être utilisées pour contenir le message.

     d TestMessage     c                   Const( 'Hello, world!' )

     c     TestMessage   DSPLY

     c                   EVAL      *InLR = *On

RPL

(Sur les calculatrices Hewlett-Packard HP-28, HP-48 et HP-49.)

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

RTE from TradeXpress

begin
   print("Hello world!",NL)
endbegin

Ruby

    puts "Hello world!"

Ruby on Rails

    render :text => "Hello, world!"

Sather

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

Scala

   object HelloWorld with Application {
     Console.println("Hello world!");
   }

Scilab

    disp("Hello World");

Scheme

    (display "Hello world!")
    (newline)

sed

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

ou

   sed "i\
Hello World" << EOF    
EOF

Seed7

$ include "seed7_05.s7i";

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

Self

   'Hello world!' print.

SPL (Shakespeare Programming Language)

Shell Unix

    #!/bin/sh
    echo "Hello world!"

Simula

   BEGIN
       outtext("Hello World!");
       outimage;
   END;

Silscript

    Intr-aff-{
        aff[Hello world!];
    }Stop-aff-

Smalltalk

Transcript show: 'Hello world!'

Ou

 1/>self inform: 'Hello world!'

SML

   print "Hello world!\n";

SNOBOL

       OUTPUT = "Hello world!"
   END

SQL

    create table MESSAGE (TEXT char(15));
    insert into MESSAGE (TEXT) values ('Hello world!');
    select TEXT from MESSAGE;
    drop table MESSAGE;

Ou (ex : en Oracle)

    SELECT 'Hello world!' FROM dual;

Ou (ex en: MySQL )

    select 'Hello world!';

Ou, plus simplement

    print 'Hello world!.'

Ou (pour le KB-SQL)

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

STARLET

    RACINE: HELLO_WORLD.

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

TACL

   #OUTPUT Hello world!

Tcl

    puts "Hello world!"

Tcl/Tk

    pack [button .b -text "Hello world!" -command exit]

TeX

   Hello world!
   \bye

Turbo Pascal

program Hello_World; {titre du programme, facultatif}
begin
  writeln('Hello World'); {affiche le message et saute une ligne}
  readln; {Sert de pause, facultatif}
end.

Turing

    put "Hello world!"

TSQL

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

ou, variation plus simple:

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

TI-59

Texas Instruments TI 58, TI 58C, TI 59 : Ce code imprime HELLO WORLD! sur l'imprimante thermique

000 69 OP 
001 00 00    efface la ligne
002 02  2 
003 03  3    H
004 01  1 
005 07  7    E
006 69 OP 
007 01 01    dans la zone de gauche
008 02  2    
009 07  7    L
010 02  2 
011 07  7    L
012 03  3 
013 02  2    O
014 00  0 
015 00  0    espace
016 04  4 
017 03  3    W
018 69 OP 
019 02 02    dans la zone milieu-gauche
020 03  3 
021 02  2    O
022 03  3 
023 05  5    R
024 02  2 
025 07  7    L
026 01  1 
027 06  6    D
028 07  7 
029 03  3    !
030 69 OP 
031 03 03    dans la zone milieu-droit
032 69 OP 
033 05 05    imprime la ligne
034 91 R/S   arrêt du programme

ou avec le TI Compiler (voir page sur la TI-59):

ClrLine
   "HE     <<line
   "LLO_W  <line
   "ORLD!  line>
PrtLine
R/S

TI-82 (calculatrice graphique)

   Disp("HELLO WORLD!")

TI-Basic

Ti 80 à Ti 92 :

:Disp "Hello world!"

Remarque : les guillemets de fermeture ne sont pas indispensables

:Disp "Hello World!

ou

:Output(X,Y,"Hello world!")

ou plus simplement :

:Output(X,Y,"Hello World!

Où X représente la ligne et Y la colonne.

Vala

 public class HelloWorld
 {
    public static int main(string[] args) {
       print("Hello world!");
       return 0;
    }
 }

Verilog

module main;
 initial
   begin
     $display("Hello, world");
     $finish ;
   end
endmodule

VHDL

 use std.textio.all;
 
 ENTITY hello IS
 END ENTITY hello;
 
 ARCHITECTURE Wiki OF hello IS
   CONSTANT message : string := "hello world";
 BEGIN
   PROCESS
     variable L: line; 
   BEGIN
     write(L, message);
     writeline(output, L);
     wait;
   END PROCESS;
 END ARCHITECTURE Wiki;

VBA (Visual Basic for Application)

Sub Main
  MsgBox "Hello world!"
End Sub

Visual Basic .NET (Application Console)

Imports System
Public Shared Sub Main()
  Console.WriteLine("Hello World!")
End Sub

Visual Basic .NET (Application Windows Forms)

Imports System.Windows.Forms
Public Shared Sub Main()
  MessageBox.Show("Hello World!")
End Sub

Le .Show n'est pas obligatoire mais les parenthèses oui

Visual DialogScript 2,3,4 et 5

   Title Hello World!
   Info Hello World!

Whitespace

empty-line

empty-line

empty-line




empty-line

empty-line

empty-line
empty-line/EOF

XSLT (eXtensible Stylesheet Language Transformations)

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
      version="2.0">
<xsl:template match="/">Hello world!</xsl:template>
</xsl:stylesheet>

XUL

<?xml version="1.0" encoding="ISO-8859-1" ?>
<window title="Hello world"
        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
<description>Hello world</description>
<label value="Hello world" />
</window>

YaBasic

 print "Hello world"

ou

 print @(1,1) "Hello world"

ou

 open window 30,100
 text 1,20,"Hello world"

Notes et références

• Portail de la programmation informatique