Liste von Hallo-Welt-Programmen/Höhere Programmiersprachen

Dies ist eine Liste von Hallo-Welt-Programmen für gebräuchliche Programmiersprachen. Für jede Sprache wird vorgeführt, wie man in ihr die einfache Aufgabe löst, den Text „Hallo Welt“ auf den Bildschirm auszugeben. Weitere Beispiele für grafische Benutzeroberflächen, Web-Technologien, exotische Programmiersprachen und Textauszeichnungssprachen sind unter Liste von Hallo-Welt-Programmen/Sonstige aufgeführt; Beispiele in Assembler für verschiedene Plattformen finden Sie unter Liste von Hallo-Welt-Programmen/Assembler.

3D Games Creator

print "Hello World"wait key

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 Programms siehe Ada Programming/Basic in den englischsprachigen Wikibooks.

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!") )

AMOS BASIC

? "Hallo Welt!"

AppleScript

display dialog "Hallo Welt!"

ASP (Active Server Pages)

<%
  Response.Write("Hallo Welt!")%>

oder verkürzt

<%="Hallo Welt!"%>

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 Messagebox ohne Titel

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

Variante 2: Startet den Editor, wartet bis dieser aktiv ist, hält das Fenster während der Ausführung des Send-Befehls aktiv und schreibt Hallo Welt! hinein.

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

AutoLISP

(princ "Hallo Welt!")

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!

BeanShell

print("Hallo Welt!");

Blitz Basic

Ohne GUI:

Graphics 800,600
SetBuffer BackBuffer()
Text 10, 10, "Hallo Welt"Flip
WaitKey
End

Mit GUI (BlitzPlus)

window = CreateWindow("Hallo Welt! Fenster", 0, 0, 100, 80, 0, 1)
label = CreateLabel("Hallo Welt!", 5, 5, 80, 20, window)Repeat
Until WaitEvent() = $803

Blitz Max

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

Boo

print "Hallo Welt!"

C/AL

MESSAGE('Hallo Welt')

C

#include <stdio.h>
 
int main(void)
{
    puts("Hallo Welt!");}

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

C ohne stdio-C-Bibliothek-Code

#include <unistd.h>
#define HALLOWELT "Hallo Welt!\n"
 
int main(void)
{
    /* write: IEEE Std 1003.1-2008 "POSIX.1-2008" */
    write(1, HALLOWELT, sizeof(HALLOWELT)-1);}

C mit GTK

/*
 * Kompilieren mit "gcc hello_world.c -o hello_world `pkg-config --cflags --libs gtk+-2.0`".
 * (Falls die Datei unter dem Namen "hello_world.c" gespeichert wurde.)
 */
#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("Hallo Welt!\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("Hallo Welt!");
  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 mit Windows API

#include <windows.h>
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
  MessageBox(0, "Hallo Welt!", "Mein erstes Programm", MB_OK);  return 0;
}

C++

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

C++/CLI

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

C++ mit gtkmm

// Kompilieren mit g++ hello_world.cpp -o hello_world `pkg-config --cflags --libs gtkmm-2.4`
// (Falls die Datei unter dem Namen "hello_world.cpp" gespeichert wurde.)
#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("Hallo Welt!");    m_window.add(m_button);
    m_button.show();
    Gtk::Main::run(m_window);
    return 0;
}

C++ mit Qt

// Kompilieren mit g++ hello_world.cpp -o hello_world `pkg-config --cflags --libs QtGui`
// (Falls die Datei unter dem Namen "hello_world.cpp" gespeichert wurde.)
#include <QLabel>
#include <QApplication>
int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    QLabel label("Hallo Welt!");
    label.show();    return app.exec();
}

C#

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

CIL

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

CLIST

WRITE HALLO WELT

Clojure

(println "Hallo Welt!")

CLP

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

COBOL

000100 IDENTIFICATION DIVISION.
000200 PROGRAM-ID. HELLOWORLD.
000900 PROCEDURE DIVISION.
001000 MAIN.
001100 DISPLAY "Hallo Welt!".001200 STOP RUN.

COLDFUSION

<cfset beispiel = "Hallo Welt!" ><cfoutput>#beispiel#</cfoutput>

COMAL

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

import std.stdio;
void main() {
    writeln("Hallo Welt!");}

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!"

Object Pascal

CLI:

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

GUI:

    program HalloWelt;
    {$APPTYPE GUI}
    uses Dialogs;     begin
      ShowMessage('Hallo Welt!');
    end.

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").

F#

printfn "Hallo Welt"

Forth

.( Hello, world!)

Fortran

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

FreeBASIC

print "Hallo Welt!"

GML

show_message("Hallo Welt!");

oder:

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

Gambas

    PUBLIC SUB Form_Enter()
    PRINT "Hallo Welt!"    END

Go

package main
 
import "fmt"
 
func main() {
        fmt.Println("Hallo Welt!")}

Groovy

println "Hello World!"

Haskell

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

Haxe

class Test {
    static function main() {        trace("Hallo Welt!");
    }
}

Die daraus compilierten SWF- oder Neko-Bytecodes sind allein lauffähig. Zur Verwendung von compiliertem Javascript zusätzlich nötig:

<html><body>
<div id=“haxe:trace“></div>
<script type=“text/javascript“ src=“hallo_welt_haxe.js“></script></body></html>

IDL (RSI)

PRO hallo_welt
    PRINT, "Hallo Welt!"END

Io

"Hallo Welt!" print

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!"; // innerHTML entspricht nicht dem w3c-Standard; besser: .nodeValue bzw. .firstChild.nodeValue

oder

window.alert("Hallo Welt!");

Java

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

oder

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

Java-Applet

Java-Applets funktionieren in Verbindung mit HTML.

Die Java-Datei:

import java.applet.*;
import java.awt.*;
 
public class HalloWelt extends Applet {
  public void paint(Graphics g) {
    g.drawString("Hallo Welt!", 100, 50);  }
}

Nachfolgend der Code zum Einbau in eine HTML-Seite. Vom W3C empfohlen:

<object classid="java:HalloWelt.class"        codetype="application/java-vm"
        width="600" height="100">
</object>

Für Kompatibilität zu sehr alten Browsern (nicht empfohlen):

<applet code="HalloWelt.class"        width="600" height="100">
</applet>

KiXtart

? "Hallo Welt!"

LaTeX

\documentclass{article}
\begin{document}
Hallo Welt!\end{document}

Alternativ (gibt Hallo Welt auf STDOUT aus, anstatt ein DVI-File damit zu erstellen):

\documentclass{article}
\begin{document}
\typeout{Hallo Welt!}\end{document}

LISP

(print "Hallo Welt!")

oder

(princ "Hallo Welt!")(terpri)

Mit terpri erfolgt Zeilenumbruch.

Logo

print [Hallo Welt!]

Lua

print ("Hallo Welt!")

Hierbei können die Klammern um den String allerdings weggelassen werden:

print "Hallo Welt!"

MATLAB

fprintf('Hallo Welt!');

oder

disp('Hallo Welt!');

oder

disp Hallo_Welt

oder

'Hallo Welt'

mIRC Script

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

MS-DOS Batch

echo Hallo Welt!

Oberon

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

OCaml

print_endline "Hallo Welt!";;

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

Objective-C mit Cocoa

#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:@"Hallo Welt!"];
 
                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:@"Hallo Welt!"];
                [[window contentView] addSubview:textField];                [window makeKeyAndOrderFront:nil];
 }
 
 return self;
}
- (void)windowWillClose:(NSNotification *)notification
{
 [NSApp terminate:self];
}
 
@end

OpenLaszlo

<canvas>
   <text>Hallo Welt!</text></canvas>

Oz

{Show 'Hello World'}

Pascal

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

PAWN

main()
{
        printf("Hallo Welt!\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 "Hallo Welt!\n";

oder

use feature qw(say);
say "Hallo Welt!";

Perl mit Tk

use Tk;
$init_win = new MainWindow;
$label = $init_win -> Label(
                            -text => "Hallo Welt!"
                            ) -> pack(
                                      -side => top
                                      );
$button = $init_win -> Button(
                              -text    => "Ok",
                              -command => sub {exit}
                              ) -> pack(
                                        -side => top                                        );
 
MainLoop;

PHP

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

oder:

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

oder:

<?="Hallo Welt!"?>

(Short Tags werden nicht empfohlen!)

oder alternativ bei CLI-Anwendungen:

<?php
    fwrite(STDOUT, "Hallo Welt!");?>

Pike

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

PL/I

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

PL/pgSQL prozedurale Spracherweiterung von PostgreSQL

BEGIN; -- Eine Transaktion beginnen
  -- Eine Funktion namens hallo wird angelegt.
  -- "void" bedeutet, dass nichts zurückgegeben wird.
  CREATE OR REPLACE FUNCTION  hallo() RETURNS void AS
  -- Der Funktionskörper wird in $$-Stringliteralen gekappselt.
  -- hier steht $body$ zwischen den $ Zeichen.
  -- Der Text zwischen den $ Zeichen muss eine länge von mindestens 0 Zeichen aufweisen.
  $body$
    BEGIN
       RAISE NOTICE  'Hallo Welt'; -- eine Notiz wird aufgerufen
    END;
  $body$ -- Ende des Funktionskörpers
  LANGUAGE plpgsql; -- die Sprache des Funktionskörpers muss angegeben werden
 
SELECT hallo();   -- Die Funktion wird mit einem SELECT aufgerufen.
   --   Die Ausgabe der Notiz erfolgt in der Konsole
ROLLBACK; -- alles rückgängig machen durch zurückrollen der Transaktion.

PL/SQL prozedurale Spracherweiterung von Oracle

CREATE OR REPLACE PROCEDURE HelloWorld AS
BEGIN
   DBMS_OUTPUT.PUT_LINE('Hallo Welt!');
END;
/
SET serveroutput ON;
exec HelloWorld;

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!");}

Postscript

Ausdruck:

%!
/Courier findfont    % Schrift auswählen20 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
shopage              % Seite ausgeben

Alternativ: (gibt Hallo Welt auf STDOUT aus, anstatt eine Seite zu drucken):

%!
(Hallo Welt!) =

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
}

PowerShell

Kommandozeile:

"Hallo Welt!"

alternativ:

Write-Host "Hallo Welt!"

oder:

echo "Hallo Welt!"

oder:

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

Dialogfenster:

[void][System.Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")[System.Windows.Forms.MessageBox]::Show("Hallo Welt!")

Progress 4GL

 DISPLAY "Hallo Welt!".

oder:

 MESSAGE "Hallo Welt!"   VIEW-AS ALERT-BOX INFO BUTTONS OK.

Prolog

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

PureBasic

In der Konsole:

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

Im Dialogfenster:

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

Im Fenster:

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

Python

Bis einschließlich Version 2 (print ist ein Schlüsselwort):

print "Hallo Welt!"

Ab Version 3 (print ist eine Funktion):

print("Hallo Welt!")

Python 2 mit Tkinter

import Tkinter as tk # `import tkinter as tk' in Python 3
 
fenster = tk.Tk()
tk.Label(fenster, text="Hallo Welt!").pack()fenster.mainloop()

QBASIC

PRINT "Hallo Welt!"

R

print ("Hallo Welt!")

oder

cat ("Hallo Welt!\n")

REXX

say "Hallo Welt!"

Ruby

puts "Hallo Welt!"

Ruby mit GTK+

require "gtk2"
Gtk::Window.new("Hallo Welt!").show_all.signal_connect(:delete_event){Gtk.main_quit}Gtk.main

Ruby mit Tk

require "tk"
TkRoot.new{ title "Hallo Welt!" }Tk.mainloop

SAC (Single Assignment C)

use StdIO: all;
int main()
{
  printf("Hello World!\n");  return(0);
}

SAS

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

oder

%put Hallo Welt!;

Scala

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

oder

object HalloWelt {
  def main(args: Array[String]) {
    println("Hallo Welt!")  }
}

Scheme

(display "Hallo Welt!")(newline)

Smalltalk

Mit Enfin Smalltalk:

'Hallo Welt!' out.

Mit VisualWorks:

Transcript show: 'Hallo Welt!'.

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("Hallo Welt!");    }
 }

Standard ML

print "Hallo Welt!\n"

SPL

debug "Hallo Welt!";

SQL

SELECT 'Hallo Welt!' AS message;

Für Oracle-Datenbanken, MySQL

SELECT 'Hallo Welt!' FROM dual;

Für IBM-DB2

SELECT 'Hallo Welt!' FROM sysibm.sysdummy1;

Für MSSQL, MySQL, PostgreSQL

SELECT 'Hallo Welt!';

StarOffice Basic

 sub main
 print "Hallo Welt!" end sub

oder:

 sub HalloWeltAlternativ
     MsgBox "Hallo Welt!" end sub

Tcl

puts "Hallo Welt!"

Tcl/Tk

label .l -text "Hallo Welt"
pack .l

TeX

Ausgabe als Zeile eines Dokumentes

Hallo, Welt!\bye

Ausgabe auf der Kommandozeile

\message{Hallo, Welt!}\end

Sollen die Beispiele interaktiv ausgeführt werden, so ist auf das erste Prompt \relax zu antworten.

XOTcl

proc hello {
puts "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;

VBScript

    MsgBox "Hallo Welt!"

Visual Basic .NET

Ausgabe in der Konsole:

Module Module1
    Sub Main()
        Console.WriteLine("Hallo Welt!")    End Sub
End Module

Ausgabe in eine Messagebox:

Class Hallo
    Sub HalloWelt
       MsgBox("Hallo Welt!")    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="Hallo Welt!"/></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("Hallo Welt!")' ;     '}
     End Sub
    ]]>
    </def:Code>
</Object>

Siehe auch

• Liste von Hallo-Welt-Programmen/Sonstige
• Liste der Programmiersprachen
• Zeittafel der Programmiersprachen

Weblinks

 Wikibooks: Auflistung von "Hello-World"-Programmen (englisch) – Lern- und Lehrmaterialien

 Commons: Screenshots und Grafiken zu Hello World – Sammlung von Bildern, Videos und Audiodateien

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