Helló Világ programpéldák

A Programozás Wiki wikiből

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ül, ugyanis bizonyos nyelvek, környezetek és eszközök nem képesek az ékezetek megjelenítésére.

Tartalomjegyzék

Szöveges felhasználói felület[szerkesztés]

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

ABC[szerkesztés]

WRITE "Hello, vilag!"

Ada[szerkesztés]

with Ada.Text_Io; use Ada.Text_Io;
procedure Hello is
begin
   Put_Line ("Hello, vilag!");
end Hello;

AmigaE[szerkesztés]

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

APL[szerkesztés]

'Hello, vilag!'

Assembly[szerkesztés]

Csak akkumulátor architektúra[szerkesztés]

Példa csak-akkumulátor architektúrára: 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 kezdeti é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[szerkesztés]

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[szerkesztés]

MOS Technology 6502, CBM KERNAL, ca65 assembler

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

Accumulator/Index mikrokódolt gép[szerkesztés]

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[szerkesztés]

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
        INT 21H
END

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

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[szerkesztés]

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[szerkesztés]

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[szerkesztés]

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[szerkesztés]

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

BASIC[szerkesztés]

CASIO-BASIC – Casio grafikus számológépeken használt BASIC-nyelv[szerkesztés]

"HELLO, VILAG!"

MS BASIC (hagyományos, strukturálatlan)[szerkesztés]

10 PRINT "Hello, vilag!"
20 END

TI-BASIC[szerkesztés]

TI–80TI–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[szerkesztés]

sub main
    print "Hello, vilag!"
end sub

Strukturált BASIC[szerkesztés]

print "Hello, vilag!"
end

BCPL[szerkesztés]

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

BLISS[szerkesztés]

%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[szerkesztés]

+++++ +++++
[
    > +++++ ++
    > +++++ +++++
    > +++
    > +
    <<<< -
]
> ++ .                  'H'
> + .                   'e'
+++++ ++ .              'l'
.                       'l'
+++ .                   'o'
>++ .                   ' '
<< +++++ +++++ +++++ .  'W'
> .                     'o'
+++ .                   'r'
----- - .               'l'
----- --- .             'd'
> + .                   '!'

Egy sorban:

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

C[szerkesztés]

#include <stdio.h>

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

C++[szerkesztés]

#include <iostream>
 
int main()
{
    std::cout << "Helló, világ!\n";
    return 0;
}

Calprola[szerkesztés]

#BTN A1
#PRI "HELLO WORLD!"
#END

CIL[szerkesztés]

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

Clean[szerkesztés]

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

CLIST[szerkesztés]

PROC 0
WRITE Hello, vilag!

COBOL[szerkesztés]

IDENTIFICATION DIVISION.
PROGRAM-ID.     HELLO-VILAG.
 
ENVIRONMENT DIVISION.
 
DATA DIVISION.
 
PROCEDURE DIVISION.
DISPLAY "Hello, vilag!".
STOP RUN.

Common Lisp[szerkesztés]

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

C# Console[szerkesztés]

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

D[szerkesztés]

import std.stdio;
int main() {
    writef("Hello, vilag!\n");
    return 0;
}

D (DTrace)[szerkesztés]

#pragma D option quiet
BEGIN
{
    printf("Hello, vilag!\n");
    exit(0);
}

DCL parancsfájl[szerkesztés]

$ write sys$output "Hello, vilag!"

Ed és Ex (Ed extended)[szerkesztés]

a
hello, vilag!
.
p

Vagy:

echo -e 'a\nhello, vilag!\n.\np'|ed
echo -e 'a\nhello, vilag!\n.\np'|ex

Eiffel[szerkesztés]

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[szerkesztés]

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

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

EUPHORIA[szerkesztés]

puts(1, "Hello, vilag!")

F#[szerkesztés]

type data =
    { first: string;
      second: string; }
 
    let myData =
        { first="Hello,";
          second="vilag!"; }
 
    let _ =
        print_string myData.first;
        print_string " ";
        print_string myData.second;
        print_newline()

Focus[szerkesztés]

-TYPE Hello vilag

Forte TOOL[szerkesztés]

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[szerkesztés]

." Hello, vilag!" CR

FORTRAN[szerkesztés]

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

FoxPro/dBase/Clipper[szerkesztés]

   ? 'Hello, vilag!'

Frink[szerkesztés]

println["Hello, vilag!"]

Gambas[szerkesztés]

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

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

Game Maker[szerkesztés]

Bizonyos objektumok draw eseményében:

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

Go[szerkesztés]

package main
func main() {
    print("Hello Világ!\n")
}


Haskell[szerkesztés]

module HelloVilag (main) where
 
main = putStr "Hello, vilag\n"

Heron[szerkesztés]

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

HP–41 és HP–42S[szerkesztés]

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

 
01 LBLTHELLO
02 THELLO, VILAG
03 PROMPT

Iptscrae[szerkesztés]

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

Io[szerkesztés]

"Hello, vilag!" print

Vagy:

write("Hello, vilag!\n")

Java[szerkesztés]

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

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

JVM[szerkesztés]

(Disassemblerkivitel: 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[szerkesztés]

WriteLine "Hello, vilag!"

[szerkesztés]

print [Hello, vilag!]

vagy

pr [Hello, vilag!]

Csak mswlogóban:

messagebox [Hi] [Hello, vilag!]

Csak magyar Comenius Logóban:

kiír [Hello, világ!]

LPC[szerkesztés]

 tell_object(this_player(), "Helló világ");
 // vagy
 write("Helló világ");

Lua[szerkesztés]

print "Hello, vilag!"

M (MUMPS)[szerkesztés]

W "Hello, vilag!"

vagy

WRITE "Hello, vilag!"

Mathematica[szerkesztés]

Print["Hello, vilag"]

Modula-2[szerkesztés]

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

MS-DOS parancsfájl[szerkesztés]

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[szerkesztés]

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

Objective C[szerkesztés]

#import <Foundation/Foundation.h>
 
int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
    NSLog(@"Hello, vilag!");
    [pool release];
    return 0;
}

OCaml[szerkesztés]

let _ =
   print_endline "Hello, vilag!";;

OPL[szerkesztés]

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

PROC hello:
  PRINT "Hello, vilag"
ENDP

OPS5[szerkesztés]

(object-class request
         ^action)

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

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

Pascal[szerkesztés]

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

Perl[szerkesztés]

print "Hello, vilag!\n";

PHP[szerkesztés]

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

vagy

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

vagy (ez csak akkor működik, ha a php-ban be van kapcsolva a short_open_tag = On, ami alapértelmezetként ki van kapcsolva!)

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

Pike[szerkesztés]

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

PL/I[szerkesztés]

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

POP-11[szerkesztés]

'Hello, vilag!' =>

Postscript[szerkesztés]

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

POV-Ray[szerkesztés]

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

Prolog[szerkesztés]

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

Python[szerkesztés]

print("Hello, vilag!")

REXX, NetRexx és Object REXX[szerkesztés]

say "Hello, vilag!"

RPL[szerkesztés]

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[szerkesztés]

puts "Hello, vilag!"

SAS[szerkesztés]

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

Sather[szerkesztés]

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

Scala[szerkesztés]

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

Scheme[szerkesztés]

(display "Hello, vilag!")
(newline)

sed[szerkesztés]

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

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

Seed7[szerkesztés]

$ include "seed7_05.s7i";
const proc: main is func
  begin
    writeln("Hello, vilag!");
  end func;

Self[szerkesztés]

'Hello, vilag!!' print.

Smalltalk[szerkesztés]

Transcript show: 'Hello, vilag!'

SML[szerkesztés]

print "Hello, vilag!\n";

SNOBOL[szerkesztés]

    OUTPUT = "Hello, vilag!"
END

SQL[szerkesztés]

create table MESSAGE (TEXT char(15));
insert into MESSAGE (TEXT) values ('Helló, Világ!');
select TEXT from MESSAGE;
drop table MESSAGE;

Vagy (például Oracle-dialektus):

select 'Helló, világ!' from dual;

Vagy (például MySQL-dialektus):

select 'Helló, világ!';

Vagy még egyszerűbben:

print 'Helló, világ!'

Vagy (KB-SQL-dialektus):

select Null from DATA_DICTIONARY.SQL_QUERY
 
FOOTER vagy HEADER vagy DETAIL vagy FINAL esemény
write "Helló, világ!"

STARLET[szerkesztés]

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

TACL[szerkesztés]

#OUTPUT Hello vilag!

Tcl[szerkesztés]

puts "Hello, vilag!"

Turing[szerkesztés]

put "Hello, vilag!"

TSQL[szerkesztés]

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

UNIX-stílusú rendszerhéj[szerkesztés]

echo 'Hello, vilag!'

Whitespace[szerkesztés]

   	  	   
	
     		  	 	
	
     		 		  
	
     		 		  
	
     		 				
	
     	     
	
     	 	 		 
	
     		 	  	
	
     		 		  
	
     		    	
	
     		  			
	
     	    	
	
     		 	
	
     	 	 
	
  
üres-sor
üres-sor/EOF

Grafikus felhasználói felületek (GUI)[szerkesztés]

AutoIt[szerkesztés]

 MsgBox(0, "Tutorial", "Hello World!")

ActionScript (Macromedia Flash MX)[szerkesztés]

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

AppleScript[szerkesztés]

display dialog "Helló, világ!"

Cocoa vagy GNUstep (Objective C-ben)[szerkesztés]

#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, Kylix[szerkesztés]

ShowMessage('Hello, vilag!');

FLTK eszközkészlet[szerkesztés]

C nyelven[szerkesztés]

#include <FL/Fl.H>
#include <FL/Fl_Window.H>
#include <FL/Fl_Button.H>

int main(int argc, char *argv[]) {
  Fl_Window* w = new Fl_Window(330, 190);
  new Fl_Button(110, 130, 100, 35, "Hello World");
  w->end();
  w->show(argc, argv);
  return Fl::run();
}

Python nyelven[szerkesztés]

#!/usr/bin/python
import fltk

window = fltk.Fl_Window(100, 100, 200, 50)
button = fltk.Fl_Button(9,10,180,30)
button.label("Hello World")
window.end()
window.show()

fltk.Fl.run()

Gambas[szerkesztés]

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

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

GTK eszközkészlet[szerkesztés]

C++ példa:[szerkesztés]

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

C# példa:[szerkesztés]

 using Gtk;
 using GtkSharp;
 using System;

 class Hello {

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

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

                 Application.Run ();

         }
 }

Euphoria példa:[szerkesztés]

 include gtk2/wrapper.e

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

Python példa:[szerkesztés]

#!/usr/bin/python
import gtk

window = gtk.Window(gtk.WINDOW_TOPLEVEL)
button = gtk.Button("Hello World")
button.connect_object("clicked", gtk.main_quit, window)
window.add(button
button.show()
window.show()

gtk.main()

Java Swing[szerkesztés]

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[szerkesztés]

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 (más néven ECMAScript) és JScript[szerkesztés]

A JavaScript egy ügyféloldali 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)[szerkesztés]

function OnEvent_Initialize(MessengerStart)
{
}
function OnEvent_Uninitialize(MessengerExit)
{
}
function OnEvent_Signin (Email) {
	if (Email == Messenger.MyEmail) {
		Debug.Trace("Hello Világ!");
		MsgPlus.DisplayToast("Hello Világ!", "Hello Világ!");
	}
}

OPL[szerkesztés]

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

(A Psion Series 3-as és annál újabb, kompatibilis PDA-kon.)

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

Qt eszközkészlet[szerkesztés]

C++ példa:[szerkesztés]

#include <QApplication>
#include <QPushButton>

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

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

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

Python példa:[szerkesztés]

#!/usr/bin/python

import sys
from PyQt4 import Qt

a = Qt.QApplication(sys.argv)
hello = Qt.QLabel("Hello World")
hello.show()
a.exec_()

REALbasic[szerkesztés]

MsgBox "Hello, vilag!"

RPL[szerkesztés]

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[szerkesztés]

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

TK eszközkészlet[szerkesztés]

Python nyelven[szerkesztés]

#!/usr/bin/python
import Tkinter

root = Tkinter.Tk()
w = Tkinter.Label(root, text="Hello, world!")
w.pack()

root.mainloop()

Tcl nyelven[szerkesztés]

#!/usr/bin/wish
button .hello -text "Hello, World!" -command { exit }
pack .hello

Visual Basic és VBA[szerkesztés]

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 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)[szerkesztés]

#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);

wxWidgets eszközkészlet[szerkesztés]

Python nyelven[szerkesztés]

#!/usr/bin/python
import wx

w=wx.App()

frame = wx.Frame(None, -1, "Test", pos=(50,50), size=(100,40), style=wx.DEFAULT_FRAME_STYLE)
button = wx.Button(frame, -1, "Hello World!", (20, 20))
frame = frame
frame.Show()

w.MainLoop()

Egyéb nyelvek[szerkesztés]

Verilog[szerkesztés]

module main;
  initial
    begin
      $display("Hello world!");
      $finish;
    end
endmodule
Egy egyszerű példa RS tárolóra (áramköri "Hello World")
module rs_ff(q, q_neg, reset, set);
  output q, q_neg;
  input reset, set;
  reg q, q_neg;

  always @(set or q)
    #1 q = !(q_neg && set);

  always @(reset or q)
    #1 q_neg= !(q && reset);
endmodule

VHDL[szerkesztés]

entity hello_world is
end hello_world;

architecture behaviour of hello_world is
begin
   process
      variable l : line;
   begin
      write (l, String'("Hello world!"));
      writeline (output, l);
      wait;
   end process;
end behaviour;