Liste von Hallo-Welt-Programmen/Programmiersprachen

Dies ist eine Liste von Hallo-Welt-Programmen für gebräuchliche Programmiersprachen. Weitere Beispiele für grafische Benutzeroberflächen, Web-Technologien, exotische Programmiersprachen und Textauszeichnungssprachen sind unter Liste von Hallo-Welt-Programmen/Sonstige aufgeführt.

4th Dimension

Alert("Hallo Welt!")

ABAP

   REPORT Z_HALLO_WELT.
   WRITE 'Hallo Welt!'.

Actionscript

trace('Hallo Welt');

ActionScript 3.0 und unter Benutzung der DocumentClass

package {
    import flash.display.Sprite;
 
    public class Main extends Sprite
    {
        public function Main() {
            trace( "Hallo Welt!" );
        }
    }
}

Ada

with Ada.Text_IO;
procedure Hallo is
begin
    Ada.Text_IO.Put_Line ("Hallo Welt!");
end Hallo;

Für eine Erklärung des Programmes siehe wikibooks:Ada_Programming/Basic.

ALGOL 60

   'BEGIN'
       OUTSTRING(2,'('HALLO WELT')');
   'END'

Anmerkung: Bei der Sprachdefinition von ALGOL 60 wurden die Ein-/Ausgabeanweisungen ausdrücklich von der Standardisierung ausgenommen, so dass deren Implementierungen stark zwischen den Compilern variieren. So wird dieser Text bei der Electrologica X1 (nach vorheriger Wahl des Ausgabekanals mit SELECTOUTPUT(2);) mit WRITETEXT('('HALLO WELT')'); statt mit dem OUTSTRING-Befehl ausgegeben.

ALGOL 68

   ( print("Hallo Welt!") )

APL

   'Hallo Welt!'

Assembler

x86-CPU, DOS, MASM

.MODEL Small
.STACK 100h
.DATA
  HW      DB      'Hallo Welt!$'
.CODE
 
start:
  MOV AX,@data
  MOV DS,AX
  MOV DX, OFFSET HW
  MOV AH, 09H
  INT 21H
  MOV AH, 4Ch
  INT 21H
end start

x86-CPU, DOS, FASM

'''FASM example of writing 16-bit DOS .COM program'''
; Kompilieren: "FASM HELLO.ASM HELLO.COM" 
  org  $100
  use16    
  mov  ah,9
  mov  dx,hello
  int  $21    ; Textausgabe
  mov  ah,$4C
  int  $21    ; Programm beenden
hello db 'Hallo Welt !!!$'

x86-CPU, Linux

  # Kompilieren mit "as -o hallo.o hallo.s; ld -o hallo hallo.o"
   .section .data
  s: .ascii "Hallo Welt!\n"
   .section .text
   .globl _start
  _start:
   movl $4,%eax      # Syscall-ID 4 (= __NR_write) 
   movl $1,%ebx      # Ausgabe-Filedeskriptor STDOUT (= 1)
   movl $s,%ecx      # Adresse des ersten Zeichens der Zeichenkette
   movl $12,%edx     # Länge der Zeichenkette (12 Zeichen)
   int $0x80         # Softwareinterrupt 0x80 um Syscall (write(1,s,12))auszuführen
   movl $1,%eax      # Syscall-ID 1 (= __NR_exit)
   movl $0,%ebx      # Rückgabewert 0 (= alles ok)
   int $0x80         # Softwareinterrupt 0x80 um Syscall (exit(0)) auszuführen

PowerPC-CPU, Linux

  # Kompilieren mit "gcc -nostdlib -s hallo.s"
      .section    .rodata
      .align 2
  .s:
      .string "Hallo Welt!\n"
  
      .section    ".text"
      .align 2
      .globl _start
  _start:
      li 0,4          # SYS_write
      li 3,1          # fd = 1 (stdout)
      lis 4,.s@ha     # buf = .s
      la 4,.s@l(4)
      li 5,12         # len = 12
      sc              # syscall
  
      li 0,1          # SYS_exit
      li 3,0          # returncode = 0
      sc              # syscall

680x0-CPU, Amiga

          ; Getestet mit ASM-One V1.01
          move.l  4.w,a6
          lea     dosn(pc),a1
          jsr     -408(a6)        ; OldOpenLibrary
  
          move.l  d0,a6
          lea     s(pc),a0
          move.l  a0,d1
          jsr     -948(a6)        ; PutStr
  
          move.l  a6,a1
          move.l  4.w,a6
          jsr     -414(a6)        ; CloseLibrary
          moveq   #0,d0
          rts
  dosn:   dc.b    "dos.library",0
  s:      dc.b    "Hallo Welt!",10,0

PA-RISC-CPU, HP-UX

  ; Kompiliert und getestet mit
  ; "as hallo.s ; ld hallo.o /usr/ccs/lib/crt0"
  ; unter HP-UX 11.0 auf einer HP9000/L2000
          .LEVEL 1.1
          .SPACE $TEXT$
          .SUBSPA $LIT$,ACCESS=0x2c
  s       .STRING "Hallo Welt!\x0a"
  
          .SPACE $TEXT$
          .SUBSPA $CODE$,ACCESS=0x2c,CODE_ONLY
          .EXPORT _start,ENTRY,PRIV_LEV=3
          .EXPORT __errno
          .EXPORT __sys_atexit
  _start
  __errno
  __sys_atexit
          ldil    L'0xC0000000,%r18
          ldi     4,%r22                  ; SYS_write
          ldi     1,%r26                  ; fd = stdout
          ldil    LR's,%r4
          ldo     RR's(%r4),%r25          ; buf = s
          be,l    4(%sr7,%r18)            ; Syscall
          ldi     12,%r24                 ; len = 12 (Branch delay slot)
  
          ldi     1,%r22                  ; SYS_exit
          be,l    4(%sr7,%r18)            ; Syscall
          ldi     0,%r26                  ; returncode = 0 (Branch delay slot)

x86-CPU, FreeBSD, Intel-Syntax

  section .data
    hello_world db 'Hallo Welt!', 0x0a
    hello_world_len equ $ - hello_world
  section .text
    align 4
    sys:
      int 0x80
      ret
    global _start
    _start:
      push hello_world_len
      push hello_world
      push 1
      mov eax, 4
      call sys
      push 0
      mov eax, 1
      call sys

SPARC-CPU, Linux

; Kompilieren mit "as -o hallo.o hallo.s; ld -o hallo hallo.o"
.section .data
 
hello_str:
    .asciz "Hallo Welt!\n"
    .align 4                ; Speicher muss aligned sein, damit wir später mit ld darauf zugreifen können
hello_str_len:
    .word . - hello_str     ; Länge der Zeichenkette (12 Zeichen)
 
.section .text
 
.global _start
_start:
    set 4, %g1              ; Syscall-ID 4 (= __NR_write)
    set 1, %o0              ; Ausgabe-Filedeskriptor STDOUT (= 1)
    set hello_str, %o1      ; Adresse des ersten Zeichens der Zeichenkette
    set hello_str_len, %l0  ; Die Stack-Adresse an der die Länge der Zeichenkette steht in local 0 laden
    ld [%l0], %o2           ; Den Wert auf den local 0 zeigt in out 2 laden
    t 0x110                 ; Softwareinterrupt 0x110 um Syscall (write(1,hello_str,hello_str_len))auszuführen
    set 1, %g1              ; Syscall-ID 1 (= __NR_exit)
    set 0, %o0              ; Rückgabewert 0 (= alles ok)
    t 0x110                 ; Softwareinterrupt 0x110 um Syscall (exit(0)) auszuführen

Assemblersprache (Jasmin):

; HelloWorld.j

.bytecode 50.0
.source HelloWorld.java
.class public HelloWorld
.super java/lang/Object

.method public <init>()V
  .limit stack 1
  .limit locals 1
  aload_0
  invokespecial java/lang/Object/<init>()V
  return
.end method

.method public static main([Ljava/lang/String;)V
  .limit stack 2
  .limit locals 1
  getstatic java/lang/System/out Ljava/io/PrintStream;
  ldc "Hallo Welt!"
  invokevirtual java/io/PrintStream/println(Ljava/lang/String;)V
  return
.end method

MIPS-32 mit erweitertem Befehlssatz

.data

helloworld: .asciiz "Hallo Welt!"

.text

	la	$a0, helloworld
	li	$v0, 4
	syscall

Autohotkey

Variante 1 - eine klassische MessageBox

   MsgBox Hallo Welt!

Variante 2 startet das Programm Notepad und tippt dort Hallo Welt ein

   Run, "notepad.exe"
   WinWaitActive, ahk_class Notepad
   Send, Hallo Welt{!}

AutoIt

Variante 1: Startet eine normale Message box ohne Titel

MsgBox(0, "", "Hallo Welt!")

Variante 2: Startet den Notepad, wartet bis Aktiv, hält das Fenster während der Ausführung des Send Befehles aktiv und schreibt Hallo Welt! rein.

Run("notepad.exe")
WinWaitActive("[CLASS:Notepad]")
SendKeepActive("[CLASS:Notepad]")
Send("Hallo Welt!",1)

awk

    BEGIN { print "Hallo Welt!" }

B

    main() {
        printf("Hallo Welt!");
    }

BASIC

Traditionelles, unstrukturiertes BASIC:

    10 PRINT "Hallo Welt!"

bzw. im Direktmodus:

   ?"Hallo Welt!"

Batch

@echo Hallo Welt!

Oder:

echo Hallo Welt!

BCPL

   GET "LIBHDR"
   
   LET START () BE
   $(
       WRITES ("Hallo Welt!*N")
   $)

BeanShell

    print("Hallo Welt!");

Beatnik

 bet you comments secret
 this file prints "Hello World!".
 It really does! (said me)
 Comments allowed
 See http://zaaf.nl/emacs/beatnik.html for the interpreter used.
 Edit here
      we have reasons,
 but whether mouse droppin' are holding up schools, feel if I want
 letters.
 Regardless of truth, agents are abandonin' units again.
 Print between lines are separate works.
    load sequentially, include users explicitly. Later and evil can me over! (antinormal)
 Does I says?
 Dust duchess schools foolings. My, my, is iceleaf over genius imposed. Can Neo have decided systems?
 But free flips become lines between continued stops. Start gets made standard.
 Help! Old world skool really stink (really!) Prerent third closest
 from weird deletion.
 Interestingly!

BETA

ORIGIN '~beta/basiclib/betaenv';
(* The classical "Hello, World" program in BETA *)
--PROGRAM: descriptor--
(# 
do 'Hello, World!' -> Screen.PutLine;
#)

Blitz Basic

Print "Hallo Welt!"
Waitkey

Blitz Max

Framework BRL.StandardIO
 
Print("Hallo Welt!")

Boo

    print "Hallo Welt!"

Brainfuck

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

C/AL

    MESSAGE('Hallo Welt')

C

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

Siehe auch: Hallo-Welt-Programm in C, Varianten der Programmiersprache C

C++

#include <iostream>
#include <ostream>
 
int main() 
{
   std::cout << "Hallo Welt!" << std::endl;
}

C++/CLI

int main()
{
    System::Console::WriteLine("Hallo Welt!");
}

C#

class MainClass
{
    public static void Main()
    {
        System.Console.WriteLine("Hallo Welt!");
    }
}

CIL

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

Clipper

? "Hallo Welt!"

CLIST

    WRITE HALLO WELT

CLP

PGM
SNDPGMMSG  MSG('Hallo Welt!') MSGTYPE(*COMP)
ENDPGM

COBOL

   000100 IDENTIFICATION DIVISION.
   000200 PROGRAM-ID.     HELLOWORLD.
   000500 ENVIRONMENT DIVISION.
   000700 DATA DIVISION.
   000900 PROCEDURE DIVISION.
   001100 MAIN-LOGIC SECTION.
   001200     DISPLAY "Hallo Welt!".
   001300     STOP RUN.

COLDFUSION

   <cfscript>
     WriteOutput("Hallo Welt!");
   </cfscript>

COMAL

    10 PRINT "Hallo Welt!"

Commodore Basic V2

10 print "Hallo Welt!";

Common Lisp

    (write-line "Hallo Welt!")

Component Pascal

MODULE HalloWelt;

IMPORT Out;

PROCEDURE Output*;
BEGIN
   Out.String ("Hallo Welt!");
   Out.Ln;
END Output;

END HalloWelt.

D

module helloworld;
 
import std.stdio;
 
void main()
{
    writefln("Hallo Welt!");
}

DarkBASIC

   print "Hallo Welt!"
   wait key

dBase/Foxpro

Ausgabe in der nächsten freien Zeile:

   ? "Hallo Welt!"

Zeilen- und spaltengenaue Ausgabe:

   @1,1 say "Hallo Welt!"

Ausgabe in einem Fenster:

   wait window "Hallo Welt!"

Dylan

define method hallo-welt()
    format-out("Hallo Welt!\n");
end method hallo-welt;

hallo-welt();

EASY

in der Variante tdbengine:

   module helloworld
   procedure Main
     cgiclosebuffer
     cgiwriteln("content-type: text/html")
     cgiwriteln("")
     cgiwriteln("Hallo Welt!")
   endproc

Eiffel

class HALLO_WELT
create
    make
feature
    make is
    do
        io.put_string("Hallo Welt!%N")
    end
end

ELAN

    putline ("Hallo Welt!");

Emacs Lisp

   (print "Hallo Welt!")

Erlang

   -module(Hallo).
   -export([Hallo_Welt/0]).
   
   Hallo_Welt() -> io:fwrite("Hallo Welt!\n").

Forth

im Direktmodus via Interpreter (z.B in einem "Forth-Script"):

   .( Hallo Welt!)

oder in kompilierter Form:

   : GREET  ." Hallo Welt!" ;   ( GREET wird durch Kompilierung erzeugt )
   GREET                        ( und unmittelbar darauf ausgeführt     )

Fortran

program hallo
write(*,*) "Hallo Welt!"
end program hallo

Fortress

   component HalloWelt
       export Executable
       run(args:String...) = print "Hallo Welt!"
   end

FreeBASIC

print "Hallo Welt!"

GML

show_message("Hallo Welt!");

oder

draw_text(x,y,"Hallo Welt!");

Groovy

def name='World'; println "Hello $name!"

Haskell

   main :: IO ()
   main = putStrLn "Hallo Welt!"

IDL (RSI)

PRO hallo_welt
    PRINT, "Hallo Welt!"
END

Io

"Hallo Welt!" print

IL (IL Assembler)

   .assembly HalloWelt { }
   .assembly extern mscorlib { }
   
   .method public static void SchreibeHalloWelt()
   {
              .maxstack 1
              .entrypoint
   
              ldstr  "Hallo Welt!"
              call   void [mscorlib]System.Console::WriteLine(string)
              ret
   }

Jass

   function test takes nothing returns nothing
       call BJDebugMsg("Hallo Welt!")
   endfunction

oder

   function test takes nothing returns nothing
       call DisplayTextToPlayer(Player(0), 0, 0, "Hallo Welt!")
       // für Spieler 1
   endfunction

oder

   function test takes nothing returns nothing
       call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "Hallo Welt!")
       // für den lokalen Spieler
   endfunction

Das ganze jetzt noch für eine bestimmte Zeit:

   function test takes nothing returns nothing
       call DisplayTimedTextToPlayer(Player(0), 0, 0, 10, "Hallo Welt!")
       // für Spieler 1 und für 10 sekunden
   endfunction

oder

   function test takes nothing returns nothing
       call DisplayTimedTextToPlayer(GetLocalPlayer(), 0, 0, 10, "Hallo Welt!")
       // für den lokalen Spieler und für 10 sekunden
   endfunction

J#

public class HalloWelt
{
    public static void main(String[] args)
    {
        System.Console.WriteLine("Hallo Welt!");
    }
}

JavaScript

document.write("Hallo Welt!");

oder

document.innerHTML="Hallo Welt!";

oder

alert("Hallo Welt!");

Java

public class Hallo 
{
  public static void main(String[] args) 
  {
    System.out.println("Hallo Welt!");            
  }
}

Lua

print ("Hallo Welt!")

Logo

   print [Hallo Welt!]

m4

   Hallo Welt!

MATLAB

fprintf('Hallo Welt!');

oder

disp('Hallo Welt!');

oder

disp Hallo_Welt

oder

"Hallo Welt"

Maschinensprache (DOS-COM-Programm auf Intel 80x86)

   BA 0B 01 B4 09 CD 21 B4  4C CD 21 48 61 6C 6C 6F
   2C 20 57 65 6C 74 21 0D  0A 24

mIRC Script

on 1:load:*: { echo Hallo Welt! }

Mixal

    TERM    EQU    18          the MIX console device number
            ORIG   1000        start address
    START   OUT    MSG(TERM)   output data at address MSG
            HLT                halt execution
    MSG     ALF    "MIXAL"
            ALF    " HALL"
            ALF    "O WEL"
            ALF    "T    "
            END    START       end of the program

MMIX, MMIXAL

string  BYTE  "Hallo Welt!",#a,0  % auszugebende Zeichenkette (#a ist ein Zeilenumbruch,
                                  % 0 schließt die Zeichenkette ab)
Main    GETA  $255,string         % Adresse der Zeichenkette in Register $255 ablegen
        TRAP  0,Fputs,StdOut      % Zeichenkette, auf die mit Register $255
                                  % verwiesen wird, nach StdOut ausgeben (Systemaufruf)
        TRAP  0,Halt,0            % Prozess beenden

MS-DOS Batch

echo Hallo Welt!

Mumps

   W "Hallo Welt!",!

Natural

   WRITE 'Hallo Welt!'.

Nemerle

class Hello {
  static Main () : void {
    System.Console.WriteLine ("Hallo Welt!");
  }
}

oder:

System.Console.WriteLine("Hallo Welt!");

Oberon

   MODULE HalloWelt;
   IMPORT Write;
   BEGIN
       Write.Line("Hallo Welt!");
   END HalloWelt.

OCaml

print_string "Hallo Welt!\n";;

Objective C

#import <stdio.h>
 
int main()
{
  puts("Hallo Welt!");
  return 0;
}

Oder mit Hilfe des Foundation-Frameworks (und in neuer typischer Schreibweise):

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

ObjectPAL (Paradox Application Language)

   method run(var eventInfo Event)
      msginfo("Info", "Hallo Welt!")
   endMethod

Object Pascal (Delphi)

program HalloWelt;
{$APPTYPE CONSOLE}
 
begin
  writeln('Hallo Welt!');
end.

Occam

PROC HelloWorld()
  []BYTE helloworldstring :
  SEQ
    helloworldstring := "Hello, World!"
    screen ! helloworldstring

OPAL

   -- Signatur und Implementation sind eigentlich zwei Dateien
   Signature HelloWorld

   FUN Hello : denotation

   Implementation HelloWorld

   FUN Hello : denotation
   DEF Hello == "Hallo Welt!\n"

OPL

   PROC Hallo:
     PRINT "Hallo Welt!"
   ENDP

Oz/Mozart

   {Show 'Hallo Welt!'}

Pascal

program Hallo ( output );
begin
  writeln('Hallo Welt!')
end.

Turbo Pascal

program HalloWelt;
 
begin
  WriteLn('Hallo Welt!');
end.

Perl

print "Hallo Welt!\n";

oder

say "Hallo Welt!";

Phalanger

<?

class Program
{
       static function Main()
       {
               echo "Hallo Welt!\n";
               return 0;
       }
}

?>

PHP

<?php
    print ("Hallo Welt!");
?>

oder:

<?php
    echo "Hallo Welt!";
?>

oder mit "short tags":

<?="Hallo Welt!"?>

Pike

int main() {
    write("Hallo Welt!\n");
    return 0;
}

PILOT

T:Hallo Welt!

PocketC

Konsole:

main() {
  puts("Hallo Welt!");
}

Dialogfenster:

main() {
  alert("Hallo Welt!");
}

In einer Textbox:

main() {
  box=createctl("EDIT","Test",ES_MULTILINE,0x000,30,30,100,30,3000);
  editset(box,"Hallo Welt!");
}

PL/I

   Test: procedure options(main);
      put skip list("Hallo Welt!");
   end Test;

PL/SQL

CREATE OR REPLACE PROCEDURE HelloWorld AS
BEGIN
   DBMS_OUTPUT.PUT_LINE('Hallo Welt!');
END;

PostScript

%!
/Courier findfont    % Schrift auswählen
20 scalefont         % auf Schriftgröße 20 skalieren
setfont              % zum aktuellen Zeichensatz machen
50 50 moveto         % (50, 50) als aktuelle Schreibposition setzen
(Hallo Welt!) show   % und dort den Text ausgeben
showpage             % Seite ausgeben

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"
 "Hallo Welt!", 0.015, 0
 pigment {
   color rgb <0, 0, 1>
 }
 translate -3*x  
}

POW!

MODULE Helloworld;
IMPORT Out;
PROCEDURE ProgMain*;
BEGIN
Out.String("Hallo Welt");
END ProgMain;
END Helloworld.

alternativ:

MODULE Helloworld;
IMPORT Display;
PROCEDURE ProgMain*;
BEGIN
Display.WriteStr("Hello World");
END ProgMain;
END Helloworld.

PowerShell Script

Kommandozeile:

   "Hallo Welt!"

alternativ:

   Write-Host "Hallo Welt!"

oder:

   echo "Hallo Welt!"

oder:

   [System.Console]::WriteLine("Hallo Welt!")

Dialogfenster:

   [System.Windows.Forms.MessageBox]::Show("Hallo Welt!")

Progress 4GL

DISPLAY "Hallo Welt!".

Prolog

   ?- write('Hallo Welt!'), nl.

Promela

 active proctype HalloWeltProc() {
   printf("Hallo Welt!");
 }

oder

 proctype HalloWeltProc() {
   printf("Hallo Welt!");
 }
 
 init {
   run HalloWeltProc();
 }

PureBasic

In der Konsole

   OpenConsole()
     Print("Hallo Welt!")
     Input() ;Beendet das Programm beim nächsten Tastendruck
   CloseConsole()

Im Dialogfenster

   MessageRequester("","Hallo Welt!",0)

Im Fenster

  If OpenWindow (1,0,0,300,50,"Hallo Welt!",#PB_Window_ScreenCentered|#PB_Window_SystemMenu)  ; Öffnet ein zentriertes Fenster
    If CreateGadgetList(WindowID(1))                                                         ; Erstellt eine Gadgetliste
     TextGadget(1,10,10,280,20,"Hallo Welt!",#PB_Text_Border)                              ; Erstellt ein Textfeld "Hallo Welt!"
    EndIf
    Repeat
      delay(0)                                                                               ; 0 ms warten (Prozessor entlasten)
      event.l = WaitWindowEvent()                                                            ; Arbeitet die Windowsevents ab
    Until event.l = #PB_Event_CloseWindow                                                    ; solange bis X gedrückt wird
    End
  EndIf

Pure Data

Patch im Quelltext

 #N canvas 0 0 300 300 10;
 #X obj 100 100 loadbang;
 #X msg 100 150 Hallo Welt;
 #X obj 100 200 print;
 #X connect 0 0 1 0;
 #X connect 1 0 2 0;

Python (bis Version 2.6)

print "Hallo Welt!"

Python (ab Version 3.0)

print("Hallo Welt!")

QBASIC

PRINT "Hallo Welt!"

R

    print ("Hallo Welt!")

oder

    cat ("Hallo Welt!\n")

REXX

    say "Hallo Welt!"

RPG

RPG 3

   C           'Hallo'   CAT ' Welt'    HALLO  10  
   C                     DSPLY          HALLO    
   C                     MOVE '1'       *INLR    

RPG 4

   C     'Hallo Welt'  dsply                      
   C                   return                     

RPG 4 (Free)

    /free
        Dsply 'Hallo Welt';      
        return;
    /end-free

RPL

   << "Hallo Welt!" 1 DISP>>

Ruby

puts 'Hallo Welt!'

SAS

data _null_;
   put "Hallo Welt!";
run;

oder

%put Hallo Welt!;

Scala

   object HalloWelt extends Application {
     println("Hallo Welt!")
   }

Scheme

(display "Hallo Welt!")
(newline)

sed

   iHallo Welt!
   Q

Seed7

$ include "seed7_05.s7i";

 const proc: main is func
   begin
     writeln("Hallo Welt!");
   end func;

Self

'Hallo Welt!' print.

Smalltalk

Mit Enfin Smalltalk:

'Hallo Welt!' out.

Mit VisualWorks:

Transcript show: 'Hallo Welt!'.

SNOBOL4

       OUTPUT = "Hallo Welt!"
   END

Spec#

using System;

public class Program
{
    public static void Main(string![]! args)        
    requires forall{int i in (0:args.Length); args[i] != null};
    {
        Console.WriteLine("Hallo Welt!");
    }
}

Standard ML

    print "Hallo Welt!\n"

SPL

    debug "Hallo Welt!";

SQL

SELECT 'Hallo Welt!' AS  message;

Für Oracle-Datenbanken

SELECT 'Hallo Welt!' FROM dual;

Für IBM-DB2

SELECT 'Hallo Welt!' FROM sysibm.sysdummy1;

Für MSSQL

SELECT 'Hallo Welt!'

StarOffice Basic

   sub main
   print "Hallo Welt!"
   end sub

Tcl

puts "Hallo Welt!"

TECO

   iHallo Welt!$ht$$

TI-Basic

TI-Basic auf dem TI-83 Plus.

   :Disp "Hallo Welt!"

oder

   :Output(1,1,"Hallo Welt!")

oder

   :Text(1,1,"Hallo Welt!")

Turing

    put "Hallo Welt!"

Unix-Shell

echo 'Hallo Welt!'

Verilog

   module hallo_welt;
   initial begin
    $display ("Hallo Welt!");
    #10 $finish;
   end
   endmodule

VHDL

entity HelloWorld is
end entity HelloWorld;
architecture Bhv of HelloWorld is
begin
  HelloWorldProc: process is
  begin
    report "Hallo Welt!";
    wait;
  end process HelloWorldProc;
end architecture Bhv;

Visual Basic .NET

Public Shared Sub Main()
  System.Console.Write("Hallo Welt!")
End Sub

X++

   print "Hallo Welt!\n";
   pause;

oder

   info("Hallo Welt!\n");

Zonnon

   module Main;
   begin
       writeln("Hallo Welt!")
   end Main.

Siehe auch

• Liste der Programmiersprachen
• Zeittafel der Programmiersprachen

Weblinks

• The Hello World Collection (über 370 Programmbeispiele)
• Index of Hello World! programs and beyond (englisch)

Einzelnachweise