„Helló, világ!” programpéldák listája

Az alábbiakban példákat láthatunk a „Helló, világ!” programokra különböző programozási nyelveken. A megjelenített szöveg a legtöbb helyen ékezetek nélküli, ugyanis bizonyos nyelvek, környezetek és eszközök nem képesek az ékezetek megjelenítésére.

Szöveges felhasználói felület

Szöveges felhasználói felületekben (TUI; más néven konzolban) használt nyelvek példái.

ABAP

report Z_HELLO_WORLD.
write 'Hello, világ!'.

ABC

WRITE "Hello, vilag!"

Ada

with Ada.Text_Io; use Ada.Text_Io;
procedure Hello is
begin
   Put_Line ("Helló, világ!");
end Hello;

AmigaE

PROC main()
   WriteF('Hello, vilag!')
ENDPROC

Ante

9♦8♥J♦A♦2♣3♥7♠J♦A♦7♦J♦J♦A♦3♦J♦5♥6♦4♥J♥A♥6♠6♠J♥A♦7♦J♦A♦9♠4♠J♦A♦3♦J♦A♦9♠2♠J♦A♦6♦J♦A♥3♦2♠J♥

APL

'Hello, vilag!'

ArnoldC

IT'S SHOWTIME
TALK TO THE HAND "Hello, vilag!"
YOU HAVE BEEN TERMINATED

Assembly

Csak Accumulator architektúra

A csak Accumulator architektúrák: DEC PDP–8, PAL–III assembler

A példa a Digital PDP–8 Handbook Series, Introduction to Programming könyvből származik.

*200                / összeállítás-származás megadása (betöltési cím)
hello,  cla cll
        tls         / tls a nyomtatójelölő megadásához.
        tad charac  / indexregiszter beállítása
        dca ir1     / a karakterek megszerzéséhez.
        tad m6      / számláló beállítása
        dca count   / a karakterek kiírásához.
next,   tad i ir1   / karakter megszerzése.
        jms type    / kiírása.
        isz count   / elkészült?
        jmp next    / nem: újabb begépelése.
        hlt
type,   0           / type szubrutin
        tsf
        jmp .-1
        tls
        cla
        jmp i type
charac, .           / az ir1 kezdetleges értéke
        310 / H
        305 / E
        314 / L
        314 / L
        317 / O
        254 / ,
        240 /
        326 / V
        311 / I
        314 / L
        300 / A
        307 / G
        241 / !
m6,     -15
count,  0
ir1 = 10
$

Első sikeres µP/OS-kombinációk

Intel 8080/Zilog Z80, CP/M, RMAC assembler

bdos    equ    0005H    ; BDOS belépési pont
start:  mvi    c,9      ; BDOS függvény: karakterlánc kivitele
        lxi    d,msg$   ; msg címe
        call   bdos
        ret             ; visszatérés a CCP-hez

msg$:   db    'Hello, vilag!$'
end     start

Accumulator + indexregisztergép

MOS Technology 6502, CBM KERNAL, ca65 assembler

HELLO:  LDX    #0
        LDA    MSG,X    ; kezdőkarakter betöltése
@LP:    JSR    $FFD2    ; chrout
        INX
        LDA    MSG,X
        BNE    @LP
        RTS
MSG:   .ASCIIZ "Hello, vilag!"

Accumulator/Index mikrokódolt gép

Data General Nova, RDOS

        ; "Helló, világ!" program RDOS-t futtató Novára; az eredetit írta: Toby Thain
        ; PCHAR rendszerhívást használ
        .titl hello
        .nrel
        .ent start

start:
dochar:
        lda 0,@pmsg ; ac0 betöltése következő karakterrel,
        mov# 0,0,snr    ; ac0 tesztelése; kihagyás ha nem nulla (ne töltse be az eredményt)
        jmp done
        .systm
        .pchar          ; első kiírása
        jmp er          ; kihagyva, ha jó
        movs 0,0        ; bájtcsere
        .systm
        .pchar          ; második kiírása
        jmp er          ; kihagyva, ha jó
        isz pmsg        ; mutatás a következő szóra
        jmp dochar      ; újrakezdés

done:   .systm          ; normál kilépés
        .rtn
er:     .systm          ; hibás kilépés
        .ertn
        halt

pmsg:   .+1             ; mutató a karakterlánc első szavához
                        ; a megjegyzésbájtok alapértelmezés szerint jobbról balra vannak csomagolva
        .txt /Hello, vilag!<15><12>/ ; CR LF
        0               ; szó megjelölése a karakterlánc befejezéséhez

        .end start

Bővített accumulator gép

Intel x86, MS-DOS, TASM

MODEL   SMALL
IDEAL
STACK   100H

DATASEG
        MSG DB 'Hello, vilag!$'

CODESEG
        MOV AX, @data
        MOV DS, AX
        MOV DX, OFFSET MSG
        MOV AH, 09H     ; DOS: ASCII$ karakterlánc kivitele
        INT 21H
        MOV AX, 4C00H   ; DOS: Kilépés a programból
        INT 21H
END

Általános célú fiktív számítógép

MIX, MIXAL

TERM    EQU     19          konzoleszköz száma (19 = írógép)
        ORIG    1000        címkezdet
START   OUT     MSG(TERM)   adat kivitele a cél-MSG-nél
        HLT                 megszakítás végrehajtása
MSG     ALF     "HELLO"
        ALF     ", VIL"
        ALF     "AG!     "
        END     START       program vége

Általános célú CISC regiszter

DEC PDP–11, RT-11, MACRO-11

.MCALL  .REGDEF,.TTYOUT,.EXIT
        .REGDEF

HELLO:  MOV #MSG,R1
        MOVB    (R1),R0
LOOP:   .TTYOUT
        MOVB    +(R1),R0
        BNE LOOP
        .EXIT

MSG:    .ASCIZ  /HELLO, VILAG!/
        .END    HELLO

CISC irányított többfolyamatos operációs rendszeren

DEC VAX, VMS, MACRO-32

        .title      hello

        .psect      data, wrt, noexe

chan:   .blkw       1
iosb:   .blkq       1
term:   .ascid      "SYS$OUTPUT"
msg:    .ascii      "Hello, vilag!"
len =   . – msg

        .psect      code, nowrt, exe

        .entry      hello, ^m<>

        ; Csatorna létesítése terminálos I/O-hoz
        $assign_s devnam=term, -
                    chan=chan
        blbc        r0, end

        ; I/O-kérelem sorba állítása
        $qiow_s     chan=chan, -
                    func=#io$_writevblk, -
                    iosb=iosb, -
                    p1=msg, -
                    p2=#len

        ; Állapot és IOSB-állapot ellenőrzése
        blbc        r0, end
        movzwl      iosb, r0

        ; Visszatérés az operációs rendszerhez
end:    ret

        .end        hello

RISC processzor

ARM, RISC OS, a BBC BASIC interpretere

.program
         ADR R0,message
         SWI "OS_Write0"
         SWI "OS_Exit"
.message
         DCS "Hello, vilag!"
         DCB 0
         ALIGN

Vagy még kisebb változat (qUE-től):

SWI"OS_WriteS":EQUS"Hello, vilag!":EQUB0:ALIGN:MOVPC,R14

Awk

BEGIN {print "Hello, vilag!"; exit}

Bash

echo 'Hello, vilag!'

BASIC

CASIO-BASIC

Casio grafikus számológépeken:

"HELLO, VILAG!"

MS BASIC (hagyományos, strukturálatlan)

10 PRINT "Hello, vilag!"
20 END

TI-BASIC

TI–80–TI–83 számológépeken:

:Disp "Hello, vilag!"

TI–89; TI–92 számológépeken:

:HelloVilag()
:Prgm
:Disp "Hello, vilag!"
:EndPrgm

StarOffice/OpenOffice Basic

sub main
    print "Hello, vilag!"
end sub

Strukturált BASIC

print "Hello, vilag!"
end

BCPL

GET "LIBHDR"

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

Befunge

"!galiv ,olleH">:#,_@

BLISS

%TITLE 'HELLO_VILAG'
MODULE HELLO_VILAG (IDENT='V1.0', MAIN=HELLO_VILAG,
        ADDRESSING_MODE (EXTERNAL=GENERAL)) =
BEGIN

    LIBRARY 'SYS$LIBRARY:STARLET';

    EXTERNAL ROUTINE
        LIB$PUT_OUTPUT;

GLOBAL ROUTINE HELLO_VILAG =
BEGIN

    LIB$PUT_OUTPUT(%ASCID %STRING('Hello, vilag!'))
END;

END
ELUDOM

Brainfuck

- [----- -- > + <] > - . 'H'
- [- > +++++ <] > ++ .   'e'
+++++ ++ .               'l'
.                        'l'
+++ .                    'o'
[- > +++++ <] > + .      'vesszo'
----- ----- -- .         ' '
-- [- > ++++ <] > -- .   'v'
[----- - > + <] > .      'i'
+++ .                    'l'
----- ----- - .          'a'
+++++ + .                'g'
- [--- > + <] > - .      '!'
[--- > + <] > - .        '\n'

Egy sorban:

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

C

#include <stdio.h>

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

C++

#include <iostream>

int main()
{
    std::cout << "Helló, világ!\n";
}

Calprola

#BTN A1
#PRI "Hello, vilag!"
#END

CIL

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

Clean

module hello

Start :: String
Start = "Hello, vilag!"

CLIST

PROC 0
WRITE Hello, vilag!

COBOL

IDENTIFICATION DIVISION.
PROGRAM-ID.     HELLO-VILAG.

ENVIRONMENT DIVISION.

DATA DIVISION.

PROCEDURE DIVISION.
DISPLAY "Hello, vilag!".
STOP RUN.

Common Lisp

(format t "Hello, vilag!~%")

C# Console

using System;

class Hello
{
    static void Main()
    {
        Console.WriteLine("Helló, világ!");
    }
}

D

import std.stdio;

void main() {
    writefln("Helló, világ!");
}

D (DTrace)

#pragma D option quiet

BEGIN
{
    printf("Hello, vilag!\n");
    exit(0);
}

DCL parancsfájl

$ write sys$output "Hello, vilag!"

ed és ex (ed extended)

a
Helló, világ!
.
p

Vagy:

echo -e 'a\nHelló, világ!\n.\np' | ed
echo -e 'a\nHelló, világ!\n.\np' | ex

Eiffel

class HELLO_VILAG

creation
    make
feature
    make is
    local
            io:BASIC_IO
    do
            !!io
            io.put_string("%N Hello, vilag!")
    end-make
end-class HELLO_VILAG

Erlang

-module(hello).
-export([hello_vilag/0]).

hello_vilag() -> io:fwrite("Hello, vilag!\n").

Euphoria

puts(1, "Hello, vilag!")

F#

printfn "Hello, vilag!"

Focus

-TYPE Hello vilag

Forte TOOL

begin TOOL HelloVilag;

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('HelloVilag!');
end method;
-- END METHOD DEFINITIONS
HAS PROPERTY
    CompatibilityLevel = 0;
    ProjectType = APPLICATION;
    Restricted = FALSE;
    MultiThreaded = TRUE;
    Internal = FALSE;
    LibraryName = 'hellovil';
    StartingMethod = (class = Hello, method = Init);

end HelloVilag;

Forth

." Hello, vilag!" CR

Fortran

   PROGRAM HELLO
   WRITE(*,10)
10 FORMAT('Hello, vilag!')
   STOP
   END

FoxPro/dBase/Clipper

? 'Hello, vilag!'

Frink

println["Hello, vilag!"]

Gambas

Lásd még a GUI részt.

PUBLIC SUB Main()
  Print "Hello, vilag!"
END

Game Maker

Bizonyos objektumok draw eseményében:

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

Go

package main

import "fmt"

func main() {
    fmt.Println("Helló, világ!")
}

Haskell

module HelloVilag (main) where

main = putStr "Hello, vilag!\n"

Heron

program HelloVilag;
functions {
  _main() {
    String("Hello, vilag!") |> GetStdOut();
  }
}
end

HP–41 és HP–42S

(Kézi Hewlett-Packard RPN-alapú alfanumerikus mérnöki számológépek.)

01 LBL<sup>T</sup>HELLO
02 <sup>T</sup>HELLO, VILAG
03 PROMPT

Iptscrae

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

Io

"Hello, vilag!" print

Vagy:

write("Hello, vilag!\n")

Java

Lásd még a GUI részt.

public class Hello {
    public static void main(String[] args) {
        System.out.println("Helló, világ!");
    }
}

JVM

(Disassembler kivitele: javap -c Hello.class)

public class Hello extends java.lang.Object {
    public Hello();
    public static void main(java.lang.String[]);
}

Method Hello()
   0 aload_0
   1 invokespecial #1 <Method java.lang.Object()>
   4 return

Method void main(java.lang.String[])
   0 getstatic #2 <Field java.io.PrintStream out>
   3 ldc #3 <String "Helló, világ!">
   5 invokevirtual #4 <Method void println(java.lang.String)>
   8 return

Kogut

WriteLine "Hello, vilag!"

Logo

A különféle Logo implementációk általában támogatják az alábbi utasításokat:

print [Hello, vilag!]
pr [Hello, vilag!]

MSWLogo

messagebox [Hi] [Hello, vilag!]

Comenius Logo

kiír [Helló, világ!]

LOLCODE

HAI 1.2
  CAN HAS STDIO?
  VISIBLE "HELLO, VILAG!!!4!"
KTHXBYE

Lua

print "Hello, vilag!"

vagy

print ("Hello, vilag!")

M (MUMPS)

W "Hello, vilag!"

vagy

WRITE "Hello, vilag!"

Malbolge

D'`_^]\JI;X9EUUSuu2rrML-&mH#GF&gU#@.bPv;)(rwpunm
3kSinmlkdib(IHdc\"!Y^]\[ZYXQu8NSLpJINGFjJI+*F?cC
B$@98=<;4Xy76543,Pq).'&%$Hih~}${Ayx}vut:xwvXnm3~

Mathematica

Print["Hello, vilag"]

MATLAB

disp('Hello, vilag!');

Modula-2

MODULE Hello;

FROM Terminal2 IMPORT WriteLn; WriteString;

BEGIN
   WriteString("Hello, vilag!");
   WriteLn;
END Hello;

MS-DOS parancsfájl

A szabványos command.com parancsértelmezővel. A @ jel opcionális, és megakadályozza a rendszert, hogy a parancs végrehajtása előtt magát a parancsot is kiírja. A @ jelet el kell hagyni az 5.0-snál korábbi MS-DOS-verziók esetén.

@echo Helló, világ!

MUF

: main
  me @ "Hello, vilag!" notify
;

Objective-C

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
    NSLog(@"Hello, vilag!");
    [pool release];
    return 0;
}

OCaml

print_endline "Hello, vilag!";;

OPL

Lásd még a GUI részt.

PROC hello:
  PRINT "Hello, vilag"
ENDP

OPS5

Lásd még: Lisp-nyelvjárások.

(object-class request
         ^action)

(startup
   (strategy MEA)
   (make request ^action hello)
)

(rule hello
   (request ^action hello)
   -->
     (write |Hello, vilag!| (crlf))
)

Pascal

program Hello;
begin
  WriteLn('Helló, világ!');
end.

Perl

print "Hello, vilag!\n";

PHP

<?php
echo "Helló, világ!";
?>

vagy

<?php
print('Helló, világ!');
?>

vagy (ha be van állítva a short_open_tag = On, ami alapértelmezetként ki van kapcsolva)

<?='Helló, világ!'?>

Pike

int main() {
  write("Hello, vilag!\n");
  return 0;
}

PL/I

Test: procedure options(main);
   declare My_String char(20) varying initialize('Hello, vilag!');
   put skip list(My_String);
end Test;

POP-11

'Hello, vilag!' =>

PostScript

%!
/Courier findfont
12 scalefont setfont
newpath
100 100 moveto
(Hello, vilag!) show
showpage

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, vilag!" 1, 0
  pigment { White }
}

PowerShell

Write-Host 'Helló, világ!'

Prolog

write('Hello, vilag!'),nl.

Python

print "Hello, vilag!"

Python 3.0-tól a print nem utasítás, hanem függvény, tehát:

print("Hello, vilag!")

R

cat("Hello, vilag!\n")

REXX, NetRexx és Object REXX

say "Hello, vilag!"

RPL

Lásd még a GUI részt.

A Hewlett-Packard HP–28, HP–48 és HP–49 sorozatú gráfszámológépeken.

<<
  CLLCD
  "Hello, vilag!" 1 DISP
  0 WAIT
  DROP
>>

Ruby

puts "Helló, világ!"

Rust

fn main() {
    println!("Helló, világ!");
}

SAS

data _null_;
put 'Hello, vilag!';
run;

Sather

class HELLO_VILAG is
  main is
   #OUT+"Hello, vilag\n";
  end;
end;

Scala

object HelloVilag with Application {
  Console.println("Hello, vilag!");
}

Scheme

(display "Helló, világ!")
(newline)

sed

Megjegyzés: Legalább egysornyi bevitelre szüksége van.

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

Seed7

$ include "seed7_05.s7i";

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

Self

'Hello, vilag!!' print.

Smalltalk

Transcript show: 'Hello, vilag!'

SML

print "Hello, vilag!\n";

SNOBOL

    OUTPUT = "Hello, vilag!"
END

SQL

Szabványos SQL

CREATE TABLE Message (text char(15));
INSERT INTO Message (text) values ('Helló, világ!');
SELECT text FROM Message;
DROP TABLE Message;

Oracle-dialektus

SELECT 'Helló, világ!' FROM dual;

MySQL-dialektus

SELECT 'Helló, világ!';

Vagy még egyszerűbben:

PRINT 'Helló, világ!'

KB-SQL-dialektus

SELECT Null from data_dictionary.sql_query

FOOTER -- vagy HEADER vagy DETAIL vagy FINAL esemény
WRITE "Helló, világ!"

Transact-SQL

Declare @Output varchar(16)
Set @Output='Helló, világ!'
Select @Output

Vagy egyszerűbb variációk:

SELECT 'Helló, világ!'

PRINT 'Helló, világ!'

STARLET

RACINE: HELLO_VILAG.

NOTIONS:
HELLO_VILAG : ecrire("Hello, vilag!").

TACL

#OUTPUT Hello vilag!

Tcl

puts "Hello, vilag!"

Turing

 put "Hello, vilag!"

Unlambda

`r`````````````.H.e.l.l.o.,. .v.i.l.a.g.!i

Whitespace

Jelmagyarázat:

• S: szóköz (Space)
• T: tabulátor (Tab)
• L: soremelés (Line feed)

A betűk megelőzik a jelzett karaktert, és a nyelv sajátosságainak megfelelően elhagyhatók. (A kód másolása esetén legyünk figyelemmel arra, hogy a #10-es ASCII-kódú soremelés karakter vágólapra helyezésnél böngészőtől és operációs rendszertől függően könnyedén átalakulhat CR-ré (#13), a kód pedig úgy működésképtelenné válik.)

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	S T	S T	T	S L
T	L
S S S S S T	T	S T	S 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 S S S T	L
T	L
S S S S S T	T	S S T	T	T	L
T	L
S S S S S T	S S S S T	L
T	L
S S L
L
L

Zig

const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello, {s}!\n", .{"world"});
}

Grafikus felhasználói felületek (GUI)

ActionScript (Adobe Flash CS6)

trace("Helló, világ!")

AppleScript

display dialog "Helló, világ!"

Cocoa vagy GNUstep (Objective C-ben)

#import <Cocoa/Cocoa.h>

@interface hello : NSObject {

}

@end

@implementation hello

-(void)awakeFromNib
{
    NSBeep(); // Nem szükséges, de szokás hangjelzést adni figyelmeztetés megjelenítésekor
    NSRunAlertPanel(@"Üzenet a számítógéptől", @"Helló, világ!", @"Hello!", nil, nil);
}

@end

Delphi, Lazarus

program HelloWorld;
uses
  Dialogs;
begin
  ShowMessage('Hello, vilag!');
end;

Gambas

Lásd még a TUI részt.

PUBLIC SUB Main()
  Message.Info("Hello, vilag!")
END

GTK

GTK (C++-ban)

#include <iostream>
#include <gtkmm/main.h>
#include <gtkmm/button.h>
#include <gtkmm/window.h>

using namespace std;

class HelloVilag : public Gtk::Window {
public:
  HelloVilag();
  virtual ~HelloVilag();
protected:
  Gtk::Button m_button;
  virtual void on_button_clicked();
};

HelloVilag::HelloVilag()
: m_button("Hello, vilag!") {
    set_border_width(10);
    m_button.signal_clicked().connect(SigC::slot(*this,
                                      &HelloVilag::on_button_clicked));
    add(m_button);
    m_button.show();
}

HelloVilag::~HelloVilag() {}

void HelloVilag::on_button_clicked() {
    cout << "Helló, világ!" << endl;
}

int main(int argc, char *argv[]) {
    Gtk::Main kit(argc, argv);
    HelloVilag hellovilag;
    Gtk::Main::run(hellovilag);
    return 0;
}

GTK# (C#-ban)

using Gtk;
using GtkSharp;
using System;

class Hello
{
    static void Main()
    {
        Application.Init();

        Window window = new Window("Helló, világ!");
        window.Show();

        Application.Run();
    }
}

GTK 2.x (Euphoriában)

include gtk2/wrapper.e

Info(NULL,"Hello","Hello, vilag!")

Java

Java Swing

Lásd még a TUI részt.

import javax.swing.JOptionPane;

public class Hello {
    public static void main(String[] args) {
        JOptionPane.showMessageDialog(null, "Helló, világ!");
        System.exit(0);
    }
}

Java-applet

A Java-kisalkalmazások HTML-fájlokkal működnek együtt.

<html>
  <head>
    <title>Helló, világ!</title>
  </head>
  <body>
    A HelloVilag program üzeni:
    <applet code="HelloVilag.class" width="600" height="100">
    </applet>
  </body>
</html>

import java.applet.*;
import java.awt.*;

public class HelloVilag extends Applet {
    public void paint(Graphics g) {
        g.drawString("Helló, világ!", 100, 50);
    }
}

JavaScript

A JavaScript egy kliensoldali parancsleírónyelv, melyet HTML-fájlokban használnak. Az alábbi kódot bármely HTML fájlban elhelyezhetjük.

<script type="text/javascript">
function helloVilag() {
    alert("Helló, világ!");
}
</script>

<a href="#" onclick="helloVilag()">Helló, világ! példa</a>

Egy egyszerűbb módszer implicit módon használja a JavaScriptet, a lefoglalt alert függvényt hívva meg. Az alábbi sort a <body> ... </body> HTML-címkék közé kell helyezni.

<a href="#" onclick="alert('Helló, világ!')">Helló, világ! példa</a>

Egy, még ennél is egyszerűbb módszer a népszerű böngészők virtuális „javascript” protokolljának használata, mellyel JavaScript-kódot lehet végrehajtani. Az alábbit internetcímként kell megadni:

javascript:alert('Helló, világ!')

Messenger Plus Live Script (JavaScript alapon, bejelentkezéskor)

function OnEvent_Initialize(MessengerStart) {
}

function OnEvent_Uninitialize(MessengerExit) {
}

function OnEvent_Signin (Email) {
    if (Email == Messenger.MyEmail) {
        Debug.Trace("Helló, világ!");
        MsgPlus.DisplayToast("Helló, világ!", "Helló, világ!");
    }
}

OPL

Lásd még a TUI részt.

(Az OPL nyelvet támogató EPOC és Symbian operációs rendszert futtató gépeken.)

PROC guihello:
  ALERT("Hello, vilag!","","Kilépés")
ENDP

Qt eszközkészlet (C++-ban)

#include <QApplication>
#include <QPushButton>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QPushButton hello("Hello, vilag!");
    hello.resize(100, 30);

    hello.show();
    return app.exec();
}

REALbasic

MsgBox "Hello, vilag!"

RPL

Lásd még a TUI részt.

A Hewlett-Packard HP–48G és HP–49G sorozatú számológépeken.

<< "Hello, vilag!" MSGBOX >>

SWT

import org.eclipse.swt.widgets.*;

public class Main {
    public static void main(String [] args) {
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.open();

        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) {
                display.sleep();
            }
        }

        display.dispose();
    }
}

Visual Basic és VBA

Ha nincs form csak egy .bas modul a Sub Main eljárás az alapértelmezett belépési pont.

Public Sub Main()
    MsgBox "Helló, világ!"
End Sub

Ha adtunk formot a projekthez, akkor például a Load eseményhez rendelhetjük hozzá az Msgbox függvény hívását:

Public Sub Form_Load()
    MsgBox "Helló, világ!"
End Sub

Windows API (C-ben)

#include <windows.h>
 
LRESULT CALLBACK WindowProcedure(HWND, UINT, WPARAM, LPARAM);
 
char szClassName[] = "MainWnd";
HINSTANCE hInstance;
 
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    HWND hwnd;
    MSG msg;
    WNDCLASSEX wincl;
 
    hInstance = hInst;
  
    wincl.cbSize = sizeof(WNDCLASSEX);
    wincl.cbClsExtra = 0;
    wincl.cbWndExtra = 0;
    wincl.style = 0;
    wincl.hInstance = hInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpszMenuName = NULL; // No menu
    wincl.lpfnWndProc = WindowProcedure;
    wincl.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); // Ablak színe
    wincl.hIcon = LoadIcon(NULL, IDI_APPLICATION); // EXE-ikon
    wincl.hIconSm = LoadIcon(NULL, IDI_APPLICATION); // Kis programikon
    wincl.hCursor = LoadCursor(NULL, IDC_ARROW); // Kurzor
 
    if (!RegisterClassEx(&wincl))
        return 0;
 
    hwnd = CreateWindowEx(0, // Nincs kiterjesztett ablakstílus
        szClassName, // Osztálynév
        "", // Ablakcím
        WS_OVERLAPPEDWINDOW & ~WS_MAXIMIZEBOX,
        CW_USEDEFAULT, CW_USEDEFAULT, // A Windows döntse el az ablak bal és felső pozícióit
        120, 50, // Ablak szélessége és magassága
        NULL, NULL, hInstance, NULL);
 
    //Az ablak látható legyen a képernyőn
    ShowWindow(hwnd, nCmdShow);
  
    //Üzenethurok futtatása
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}
 
LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT ps;
    HDC hdc;
    switch (message)
    {
    case WM_PAINT:
        hdc = BeginPaint(hwnd, &ps);
        TextOut(hdc, 15, 3, "Helló, világ!", 13);
        EndPaint(hwnd, &ps);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hwnd, message, wParam, lParam);
    }
    return 0;
}

Vagy sokkal egyszerűbben:

#include <windows.h>

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    MessageBox(NULL, "Helló, világ!", "", MB_OK);
    return 0;
}

Vizuális nyelvek

Piet