Hello world program - Definition and Overview

A "hello world" program is a computer program that prints out "Hello, world!" on a display device. It is used in many introductory tutorials for teaching a programming language and many students use it as their first programming experience in a language.

Such a program is typically one of the simpler programs possible in a computer language. Some are surprisingly complex, especially in some graphical user interface (GUI) contexts. Some others are very simple, however, especially those which rely heavily on a particular command line interpreter ("shell") to perform the actual output. In many embedded systems, the text may be sent to a one or two-line LCD display (and in yet other systems, a simple LED being turned on may substitute for "Hello world!").

A "hello world" program can be a useful sanity test to make sure that a language's compiler, development environment, and run-time environment are correctly installed. Configuring a complete programming toolchain from scratch to the point where even trivial programs can be compiled and run may involve substantial amounts of work. For this reason, a simple program is used first when testing a new tool chain.

While small test programs existed since the development of programmable computers, the tradition of using the phrase "Hello world!" as the test message was influenced by an example program in the book The C Programming Language, by Brian Kernighan and Dennis Ritchie, published in 1978. The example program from that book prints "hello, world" (i.e., no capital letters, no exclamation sign; those have entered the tradition later). The book had inherited the program from a 1974 Bell Laboratories internal memorandum by Kernighan —Programming in C: A Tutorial— which shows the first known version of the program:

   main( ) {
       printf("hello, world");
   }

However, the first known instance of the usage of the words "hello" and "world" together in computer literature is in A Tutorial Introduction to the Language B, by Brian Kernighan, 1973. [1] (http://cm.bell-labs.com/cm/cs/who/dmr/bintro.html)

A collection of "hello world" programs written in various computer languages can serve as a very simple "Rosetta Stone" to assist in learning and comparing the languages. Keep in mind, however, that unless assembly language or similar very low-level (hardware-near) languages are involved, not much "computing" (calculation) is usually exhibited.

Here are some examples in different languages:

Text user interface (TUI) (aka console, line-oriented)

ABC

   WRITE "Hello World"

Ada

   with Ada.Text_IO;

   procedure Hello is
   begin
      Ada.Text_IO.Put_Line ("Hello, world!");
   end Hello;

For explanation see wikibooks:Programming:Ada:Basic.

AmigaE

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

APL

   'Hello World'

Assembly language

Accumulator-only architecture: DEC PDP-8, PAL-III assembler

See the example section of the PDP-8 article.

First successful µP/OS combinations: Intel 8080/Zilog Z80, CP/M, RMAC assembler

   bdos    equ    0005H    ; BDOS entry point
   start:  mvi    c,9      ; BDOS function: output string
           lxi    d,msg$   ; address of msg
           call   bdos
           ret             ; return to CCP

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

Accumulator + index register machine: MOS Technology 6502, CBM KERNAL, ca65 assembler

   MSG:   .ASCIIZ "Hello, world!"
           LDX    #0
           LDA    MSG,X    ; load initial char
   @LP:    JSR    $FFD2    ; chrout
           INX
           LDA    MSG,X
           BNE    @LP
           RTS

Accumulator/Index microcoded machine: Data General Nova, RDOS

See the example section of the Nova article.

Expanded accumulator machine: Intel x86, DOS, TASM

   MODEL   SMALL
   IDEAL
   STACK   100H

   DATASEG
           MSG DB 'Hello, world!', 13, '$'

   CODESEG
           MOV AX, @data
           MOV DS, AX
           MOV DX, OFFSET MSG
           MOV AH, 09H      ; DOS: output ASCII$ string
           INT 21H
           MOV AX, 4C00H
           INT 21H
   END

Expanded accumulator machine: Intel x86, Linux, GAS

   .data
   msg:
   	.ascii	"Hello, world!\n"
   	len = . - msg
   .text
       .global _start
   _start:
   	movl	$len,%edx
   	movl	$msg,%ecx
   	movl	$1,%ebx
   	movl	$4,%eax
   	int	$0x80
   	movl	$0,%ebx
   	movl	$1,%eax
   	int	$0x80

General-purpose fictional computer: MIX, MIXAL

   TERM    EQU    19          console device no. (19 = typewriter)
           ORIG   1000        start address
   START   OUT    MSG(TERM)   output data at address MSG
           HLT                halt execution
   MSG     ALF    "HELLO"
           ALF    " WORL"
           ALF    "D    "
           END    START       end of program

General-purpose-register CISC: 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, WORLD!/
          .END    HELLO

CISC on advanced multiprocessing OS: DEC VAX, VMS, MACRO-32

           .title    hello

           .psect    data, wrt, noexe

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

           .psect    code, nowrt, exe

           .entry    hello, ^m<>

           ; Establish a channel for terminal I/O
           $assign_s devnam=term, -
                     chan=chan
           blbc      r0, end

           ; Queue the I/O request
           $qiow_s   chan=chan, -
                     func=#io$_writevblk, -
                     iosb=iosb, -
                     p1=msg, -
                     p2=#len

           ; Check the status and the IOSB status
           blbc      r0, end
           movzwl    iosb, r0

           ; Return to operating system
   end:    ret

          .end       hello

RISC processor: ARM, RISC OS, BBC BASIC's in-line assembler

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

or the even smaller version (from qUE);

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

AWK

   BEGIN { print "Hello, world!" }

BASIC

The following example works for any ANSI/ISO-compliant BASIC implementation, as well as most implementations built into or distributed with microcomputers in the 1970s and 1980s (usually some variant of Microsoft BASIC).

   10 PRINT "Hello, world!"
   20 END

Later implementations of BASIC allowed greater support for structured programming and did not require line numbers. The following example works for the vast majority of modern BASICs.

   PRINT "Hello, world!"
   END

TI-BASIC

On TI-80-TI-86 calculators.

   :Disp "Hello, world!"

or

   :Output(1,1,"Hello, world!")

or simply

   :"Hello, world!"

On TI-89/TI-92 calculators.

   :HelloWorld()
   :Prgm
   :Disp "Hello, world!"
   :EndPrgm

StarOffice/OpenOffice Basic

   sub main
       print "Hello, World"
   end sub

Visual Basic

To output to the debug console:

   Debug.Print "Hello, world!"

To output a message box to the user:

   VBA.Interaction.MsgBox "Hello, world!"

BCPL

   GET "LIBHDR"

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

BLISS

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

       LIBRARY 'SYS$LIBRARY:STARLET';

       EXTERNAL ROUTINE
          LIB$PUT_OUTPUT;

   GLOBAL ROUTINE HELLO_WORLD =
   BEGIN

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

   END
   ELUDOM

boo

   print "Hello, world!"

C

   #include <stdio.h>

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

C#

   using System;

   class HelloWorldApp {
       public static void Main() {
           Console.WriteLine("Hello, world!");
       }
   }

C++

   #include <iostream>

   int main()
   {
       std::cout << "Hello, world!" << std::endl;

       return 0;
   }

ColdFusion (CFM)

   <cfoutput>
   Hello, world!
   </cfoutput>

COMAL

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

Common Lisp

   (format t "Hello world!~%")

or

   (write-line "Hello World!")

D

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

DCL batch

   $ write sys$output "Hello, world!"

Ed and Ex (Ed extended)

   a
   hello world!
   .
   p

or like so:

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

Eiffel

   class HELLO_WORLD

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

Erlang

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

   hello_world() -> io:fwrite("Hello, world!\n").

EUPHORIA

   puts(1, "Hello, world!")

F#

   type data =
       { first: string;
         second: string; }

       let myData =
           { first="Hello";
             second="world"; }

       let _ =
           print_string myData.first;
           print_string " ";
           print_string myData.second;
           print_newline()

Focus

   -TYPE 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('HelloWorld!');
   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

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

Frink

   println["Hello, world!"]

Gambas

See also GUI section.

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

Game Maker

In the draw event of some object:

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

Haskell

   module Main (main) where

   main = putStr "Hello World\n"

or

   main = putStr "Hello World\n"

Heron

   program HelloWorld;
   functions {
     _main() {
       print_string("Hello, world!");
     }
   }
   end

HP-41 & HP-42S

(Handheld Hewlett-Packard RPN-based alphanumeric engineering calculators.)

   01 LBLTHELLO
   02 THELLO, WORLD
   03 PROMPT

IDL

   print,"Hello world!"

Inform

   [ Main;
     print "Hello, world!^";
   ];

Io

   "Hello world!" print

or

   write("Hello world!\n")

Iptscrae

   ON ENTER {
       "Hello, " "World!" & SAY
   }

Java

See also GUI section.

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

JVM

(disassembler output of 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 "Hello, world!">
      5 invokevirtual #4 <Method void println(java.lang.String)>
      8 return

Kogut

   WriteLine "Hello, world!"

Logo

   print [hello  world!]

or

   pr [Hello World!]

In mswlogo only

   messagebox [Hi] [Hello World]

Lua

   print "Hello, world!"

M (MUMPS)

   W "Hello, world!"

Macsyma, Maxima

   print("Hello, world!")$

Maple

   print("Hello, World!");

Mathematica

   Print["Hello World"]

MATLAB

   disp('Hello World')

Modula-2

   MODULE Hello;

   FROM Terminal2 IMPORT WriteLn; WriteString;

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

MS-DOS batch

(with the standard command.com interpreter. The @ symbol is optional and prevents the system from repeating the command before executing it. The @ symbol must be omitted on versions of MS-DOS prior to 3.0.)

   @echo Hello, world!

MUF

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

Oberon

  MODULE Hello;
          IMPORT Oberon, Texts;
   VAR W: Texts.Writer;

   PROCEDURE World*;
   BEGIN
     Texts.WriteString(W, "Hello World!");
     Texts.WriteLn(W);
     Texts.Append(Oberon.Log, W.buf)
   END World;

  BEGIN
   Texts.OpenWriter(W)
  END Hello.

Objective C

   #import <Foundation/Foundation.h>

   int main (int argc, const char * argv[])
   {
      NSLog(@"Hello, World!");
      return 0;
   }

OCaml

   let _ =
      print_endline "Hello world!";;

OPL

See also GUI section.

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

Pascal

   Program Hello;
   begin
       WriteLn('Hello, world!');
   end.

Perl

   print "Hello, world!\n";

(This is the first example of Learning Perl.)

PHP

   <?php
   echo "Hello, world!\n";
   ?>

or

   <?="Hello World!\n"?>

Pike

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

PL/SQL

   procedure print_hello_world as
       dbms_output.put_line("Hello World!");
   end print_hello_world;

PL/I

   Test: proc options(main) reorder;
     put skip edit('Hello, world!') (a);
   end Test;

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

Processing

   println("Hello world!");

Prolog

   write('Hello world'),nl.

Python

   print "Hello, world!"

REXX, NetRexx, and Object REXX

   say "Hello, world!"

RPL

See also GUI section.

(On Hewlett-Packard HP-28, HP-48 and HP-49 series graphing calculators.)

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

Ruby

See also GUI section.

   puts "Hello, world!"

SAS

   data _null_;
   put 'Hello World!';
   run;

Sather

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

Scala

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

Scheme

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

sed

(note: requires at least one line of input)

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

Self

   'Hello, World!' print.

Smalltalk

   Transcript show: 'Hello, world!'; cr

SML

   print "Hello, world!\n";

SNOBOL

       OUTPUT = "Hello, world!"
   END

SPARK

   with Spark_IO;
   --# inherit Spark_IO;
   --# main_program;

   procedure Hello_World
   --# global in out Spark_IO.Outputs;
   --# derives Spark_IO.Outputs from Spark_IO.Outputs;
   is
   begin
      Spark_IO.Put_Line (Spark_IO.Standard_Output, "Hello, world!", 0);
   end Hello_World;

SPITBOL

       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;

or (e.g. Oracle dialect)

   SELECT 'Hello, world!' FROM dual;

or (for Oracle's PL/SQL proprietary procedural language)

   SET SERVEROUTPUT ON
   BEGIN
   DBMS_OUTPUT.PUT_LINE('Hello World, from PL/SQL');
   END;

or (e.g. MySQL dialect)

   SELECT 'Hello, world!';

or (e.g. T-SQL dialect)

   PRINT 'Hello, world!'

or (for KB-SQL dialect)

   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 (Tool command language)

See also GUI section.

   puts "Hello, world!"

Turing

   put "Hello, world!"

TSQL

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

     or, simpler variations:

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

UNIX-style shell

   echo 'Hello, world!'

or

   printf "Hello, world!\n"

Graphical user interfaces (GUIs)

ActionScript (Macromedia flash mx)

   trace ("hello, world!")

AppleScript

   display dialog "Hello, world!"

Or to have the OS synthesize it and literally say "hello world!"

  say "Hello world!" -- no comma as that would cause the synthesizer to pause

Cocoa or GNUStep (In Objective C)

  #import <Cocoa/Cocoa.h>
  @interface hello : NSObject {
  }
  @end
  
  @implementation hello
  
  -(void)awakeFromNib
  {	
       NSBeep(); // we don't need this but it's conventional to beep 
                 // when you show an alert
       NSRunAlertPanel(@"Message from your Computer", @"Hello, world!", @"Hi!",
                       nil, nil);
  }
  
  @end

Delphi,Kylix

   ShowMessage("Hello, world!");

FLTK2 (in C++)

   #include <fltk/Window.h>
   #include <fltk/Widget.h>
   #include <fltk/run.h>
   using namespace fltk;
   
   int main(int argc, char **argv)
   {
       Window *window = new Window(300, 180);
       window->begin();
           Widget *box = new Widget(20, 40, 260, 100, "Hello, World!");
           box->box(UP_BOX);
           box->labelfont(HELVETICA_BOLD_ITALIC);
           box->labelsize(36);
           box->labeltype(SHADOW_LABEL);
       window->end();
       window->show(argc, argv);
   
       return run();
   }

Gambas

See also TUI section.

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

GTK toolkit (in C++)

   #include <iostream>
   #include <gtkmm/main.h>
   #include <gtkmm/button.h>
   #include <gtkmm/window.h>
   using namespace std;

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

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

   HelloWorld::~HelloWorld() {}

   void HelloWorld::on_button_clicked() {
       cout << "Hello, world!" << endl;
   }

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

GTK# (in C#)

   using Gtk;
   using GtkSharp;
   using System;

   class Hello {

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

           Window window = new Window ("helloworld");
           window.Show();

           Application.Run ();

       }
   }

GTK 2.x (in Euphoria)

   include gtk2/wrapper.e

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

Java

See also TUI section.

   import javax.swing.JOptionPane;

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

Java applet

Java applets work in conjunction with HTML files.

   <HTML>
   <HEAD>
   <TITLE>Hello World</TITLE>
   </HEAD>
   <BODY>

   HelloWorld Program says:

   <APPLET CODE="HelloWorld.class" WIDTH=600 HEIGHT=100>
   </APPLET>

   </BODY>
   </HTML>

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

   public class HelloWorld extends Applet {
     public void paint(Graphics g) {
       g.drawString("Hello, world!", 100, 50);
     }
   }

JavaScript and JScript

JavaScript (an implementation of ECMAScript) is a client-side scripting language used in HTML files. The following code can be placed in any HTML file:

   <script type="text/javascript"><!--
   function helloWorld()
   {
       alert("Hello, world!");
   }
   //--></script>

   <a href="#" onclick="helloWorld(); return false;">Hello World Example</a>

An easier method uses JavaScript implicitly, directly calling the reserved alert function. Cut and paste the following line inside the <body> .... </body> HTML tags.

   <a href="#" onclick="alert('Hello, world!'); return false;">Hello World Example
   </a>

An even easier method involves using popular browsers' support for the virtual 'javascript' protocol to execute JavaScript code. Enter the following as an Internet address (usually by pasting into the address box):

   javascript:alert('Hello, world!');

There is an almost infinite number of ways to do it:

   javascript:document.write('Hello, world!\n');

OPL

See also TUI section.

(On Psion Series 3 and later compatible PDAs.)

   PROC guihello:
     ALERT("Hello, world!","","Exit")
   ENDP

Qt toolkit (in C++)

   #include <qapplication.h>
   #include <qpushbutton.h>
   #include <qwidget.h>
   #include <iostream>

   class HelloWorld : public QWidget
   {
       Q_OBJECT

   public:
       HelloWorld();
       virtual ~HelloWorld();
   public slots:
       void handleButtonClicked();
       QPushButton *mPushButton;
   };

   HelloWorld::HelloWorld() :
       QWidget(),
       mPushButton(new QPushButton("Hello, World!", this))
   {
       connect(mPushButton, SIGNAL(clicked()), this, SLOT(handleButtonClicked()));
   }

   HelloWorld::~HelloWorld() {}

   void HelloWorld::handleButtonClicked()
   {
       std::cout << "Hello, World!" << std::endl;
   }

   int main(int argc, char *argv[])
   {
       QApplication app(argc, argv);
       HelloWorld helloWorld;
       app.setMainWidget(&helloWorld);
       helloWorld.show();
       return app.exec();
   }

REALbasic

   MsgBox "Hello, world!"

RPL

See also TUI section.

(On Hewlett-Packard HP-48G and HP-49G series calculators.)

   << "Hello, World!" MSGBOX >>

RTML

   Hello ()
   TEXT "Hello, world!"

SWT

   import org.eclipse.swt.SWT;
   import org.eclipse.swt.layout.RowLayout;
   import org.eclipse.swt.widgets.Display;
   import org.eclipse.swt.widgets.Shell;
   import org.eclipse.swt.widgets.Label;

   public class SWTHello {
       public static void main (String [] args) {
           Display display = new Display ();
           final Shell shell = new Shell(display);
           RowLayout layout = new RowLayout();
           layout.justify = true;
           layout.pack = true;
           shell.setLayout(layout);
           shell.setText("Hello, World!");
           Label label = new Label(shell, SWT.CENTER);
           label.setText("Hello, World!");
           shell.pack();
           shell.open ();
           while (!shell.isDisposed ()) {
               if (!display.readAndDispatch ()) display.sleep ();
           }
           display.dispose ();
       }
   }

SWT_Hello_World.gif
Image:SWT Hello World.gif

Tcl/Tk

See also TUI section.

   label .l -text "Hello, world!"
   pack .l

Visual Basic incl VBA

   Sub Main()
       MsgBox "Hello, world!"
   End Sub

Windows API (in C)

   #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); //Color of the window
     wincl.hIcon = LoadIcon(NULL, IDI_APPLICATION); //EXE icon
     wincl.hIconSm = LoadIcon(NULL, IDI_APPLICATION); //Small program icon
     wincl.hCursor = LoadCursor(NULL, IDC_ARROW); //Cursor

     if (!RegisterClassEx(&wincl))
           return 0;

     hwnd = CreateWindowEx(0, //No extended window styles
           szClassName, //Class name
           "", //Window caption
           WS_OVERLAPPEDWINDOW & ~WS_MAXIMIZEBOX,
           CW_USEDEFAULT, CW_USEDEFAULT, //Let Windows decide the left and top
                                         //positions of the window
           120, 50, //Width and height of the window,
           NULL, NULL, hInstance, NULL);

     //Make the window visible on the screen
     ShowWindow(hwnd, nCmdShow);

     //Run the message loop
     while (GetMessage(&msg, NULL, 0, 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, "Hello, world!", 13);
           EndPaint(hwnd, &ps);
           break;
     case WM_DESTROY:
           PostQuitMessage(0);
           break;
     default:
           return DefWindowProc(hwnd, message, wParam, lParam);
     }
     return 0;
   }

Or, much more simply:

   #include <windows.h>
   int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine,
                      int nCmdShow)
   {
       MessageBox(NULL, "Hello, world!", "", MB_OK);
       return 0;
   }

Windows Script Host

   WScript.Echo "Hello, world!"

Ruby with WxWidgets

See also TUI section.

   require 'wxruby'

   class HelloWorldApp < Wx::App
    def on_init
     ourFrame = Wx::Frame.new(nil, -1, "Hello, world!").show
     ourDialogBox = Wx::MessageDialog.new(ourFrame, "Hello, world!", "Information:", \
                    Wx::OK|Wx::ICON_INFORMATION).show_modal
    end
   end

   HelloWorldApp.new.main_loop

XUL

    <window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
    <box align="center">
    <label value="Hello, world!" />
    </box>
    </window>

Esoteric programming language

Brainfuck

   +++++++++
   [
   >+++++++>++++++++++>+++>+<<<<-
   ]
   >++. The initial loop after which an 'H' is printed
   >+. e
   +++++++. l
   . l
   +++. o
   >++.
   <<+++++++++++++++.
   >.
   +++.
   ------.
   --------.
   >+.
   >.

L33t programming language

   Gr34t l33tN3$$?
   M3h...
   iT 41n't s0 7rIckY.
   
   l33t sP33k is U8er keWl 4nD eA5y wehn u 7hink 1t tHr0uGh.
   1f u w4nn4be UB3R-l33t u d3f1n1t3lY w4nt in 0n a b4d4sS h4xX0r1ng s1tE!!! ;p
   w4r3Z c0ll3cT10n2 r 7eh l3Et3r!
   
   Qu4k3 cL4nS r 7eh bE5t tH1ng 1n teh 3nTIr3 w0rlD!!!
   g4m3s wh3r3 u g3t to 5h00t ppl r 70tAl1_y w1cK1d!!
   I'M teh fr4GM4stEr aN I'lL t0t41_1Ly wIpE teh phr34k1ng fL00r ***j3d1 5tYlE*** wItH y0uR h1dE!!!! L0L0L0L!
   t3lEphR4gG1nG l4m3rs wit mY m8tes r34lLy k1kK$ A$$
   
   l33t hAxX0r$ CrE4t3 u8er- k3wL 5tUff lIkE n34t pR0gR4mm1nG lAnguidGe$...
   s0m3tIm3$ teh l4nGu4gES l00k jUst l1k3 rE41_ 0neS 7o mAkE ppl Th1nk th3y'r3 ju$t n0rMal lEE7 5pEEk but th3y're 5ecRetLy c0dE!!!!
   n080DY unDer5tAnD$ l33t SpEaK 4p4rT fr0m j3d1!!!!!
   50mE kId 0n A me$$4gEb04rD m1ghT 8E a r0xX0r1nG hAxX0r wH0 w4nT2 t0 bR34k 5tuFf, 0r mAyb3 ju5t sh0w 7eh wAy5 l33t ppl cAn 8E m0re lIkE y0d4!!! hE i5 teh u8ER!!!!
   1t m1ght 8E 5omE v1rus 0r a Pl4ySt4tI0n ch34t c0dE.
   1t 3v3n MiTe jUs7 s4y "H3LL0 W0RLD!!!" u ju5t cAn'T gu3s5.
   tH3r3's n3v3r anY p0iNt l00KiNg sC3pT1c4l c0s th4t, be1_1Ev3 iT 0r n0t, 1s whAt th1s 1s!!!!!
   
   5uxX0r5!!!L0L0L0L0L!!!!!!!

Document Formats

ASCII

The following sequence of characters, expressed in hexadecimal notation (with carriage return and newline characters at end of sequence):

    48 65 6C 6C 6F 2C 20 77 6F 72 6C 64 21 0D 0A

The following sequence of characters, expressed as binary numbers (with cr/nl as above, and the same ordering of bytes):

    00--07: 01001000 01100101 01101100 01101100 01101111 00101100 00100000 01110111
    08--0F: 01101111 01110010 01101100 01100100 00100001 00001101 00001010 DONTCARE*

(* The DONTCARE marker fills in for byte #0F, i.e. #15, which comes after our string.)

HTML 4.01 Strict

(Using UTF-8 character set.)

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
                          "http://www.w3.org/TR/html4/strict.dtd">
    <html>
      <head>
        <title>Hello, world!</title>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      </head>
      <body>
        <p>Hello, world!</p>
      </body>
    </html>

LaTeX

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

RTF

   {\rtf1\ansi\deff0
   {\fonttbl {\f0 Courier New;}}
   \f0\fs20 Hello, world!
   }

XHTML 1.1

(Using UTF-8 character set.)

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
                          "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
    <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
      <head>
        <title>Hello, world!</title>
      </head>
      <body>
        <p>Hello, world!</p>
      </body>
    </html>

Page description languages

PostScript

   /Courier findfont 24 scalefont setfont
   100 100 moveto
   (Hello world!) show
   showpage

In executing the interpreter, one can simply write

(Hello world!) stack

TeX

   Hello world
   \bye

See also

• Hello world program in esoteric languages
• Fibonacci number program
• Trabb Pardo-Knuth algorithm
• Just another Perl hacker
• List of basic computer science topics

External links

• ACM "Hello World" project (http://www.latech.edu/~acm/HelloWorld.shtml)
• "How the way people code "Hello World" varies depending on their age and job" (http://www.gnu.org/fun/jokes/helloworld.html) – From the GNU Humor Collection
• A Collection of Hello World Programs (http://www.cuillin.demon.co.uk/nazz/trivia/hw/hello_world.html)
• Another Collection of Hello World Programs (http://www.roesler-ac.de/wolfram/hello.htm)