Some pretty interesting stuff in this thread. I though I might step right out of the box and do something that can be put into the MBR (Master Boot Record) and copied to a floppy. I choose to provide the listing like this incase someone wanted to try it out without using an assembler. If you alread have a bootable floppy disk it would work just find.

First 3 bytes are memory address and the rest are opcodes for 386 or better

000 FA				 cli
001 FC				 cld
002 B8C007			 mov ax, 0x7c0
005 8ED8				 mov ds, ax
007 8EC0				 mov es, ax ; Setup segments to boot area
009 8ED0				 mov ss, ax
00B BCFFFF			 mov sp, 0xffff
00E FB					 sti
00F BD[2500]			 mov bp, Msg
012 B92000				mov cx, MsgLen
015 BA100A			 mov dx, 0x0a10 ; DH = Row (10), DL = Column (16)
018 B304				 mov bl, 4 ; Red
01A B80113			 mov ax, 0x1301 ; AH = Write String, AL = chars only
01D CD10				 int 0x10 ; Video serice call
01F 31C0				 xor ax, ax
021 CD16				 int 0x16 ; Wait for operators input
023 CD19				 int 0x19 ; Re-boot
025 48454C4C4F20574F52- Msg db 'HELLO WORLD', 13, 10, 'Any key to continue'
02E 4C440D0A416E79206B-
037 657920746F20636F6E-
040 74696E7565		 
						 MsgLen equ $ - Msg
045 90<rept>			times 510 - ($-$$) nop
1FE 55AA				db 0x55, 0xaa

and the formatting is what it is. Cutting and pasting between code tags is probably the most cumbersome thing I've ever used.

>Well I downloaded tama and like nothing happened i tried running it and stuff and nothing happened
The driver expects a file with valid Tama script to be passed as a command line argument. For example:

$ tama source_file

It's also entirely possible that you're running the code with an IDE that closes the window immediately after the program finishes. In that case, search the C/C++ forum for how to fix it.

I wonder what ever happened to Modula2, once touted as theee super language!


FROM InOut IMPORT WriteString, WriteLn;
  WriteString("Hello World! in Modula2");
END HelloWorld.

The Ruby world has responded with a GUI Hello World!

require 'fox'

include Fox

theApp =

theMainWindow =, "Hello World!",nil, nil, DECOR_ALL, 10, 10, 300, 100), " Hello World! using Ruby and fxRuby")

I understand this is the A language that led to B then C. Correct me, if I am wrong ...

( # Hello # print(("Hello World! in Algol 68",newline)))

>Correct me, if I am wrong ...
C is derived from B, which is derived from BCPL, which is derived from CPL, which is derived from Algol 60, which is rooted in FORTRAN derivatives.

Thanks Narue! Found the other ancestors but not CPL ...

// Hello world example in BCPL
GET "libhdr"

LET start() = VALOF
$( writes("Hello world*N")
   'COMMENT' Hello World example in Algol 60;
    OUTPUT(4,'(''('Hello World!')',/')')

This dates me again, had that in punch-card college ...

C      Hello World example in Fortran-IV
       WRITE (6,'('' Hello World!'')')

There was a time when the world belonged to ADA. At least the ADA programmers cogitated so.

with TEXT_IO;
use TEXT_IO;
procedure Hello is
  pragma MAIN;
  PUT ("Hello World! in Ada");
end Hello;

The up and coming language ...

indexing "Hello"
class HELLO
   run is
       io : BASIC_IO;
       io.put_string("Hello World! in Eiffel");

There was a time when the world belonged to ADA. At least the ADA programmers cogitated so.

with TEXT_IO;
use TEXT_IO;
procedure Hello is
  pragma MAIN;
  PUT ("Hello World! in Ada");
end Hello;

What does ADA stand for? American Dental Agency? Americans with Disabilities Act? What do they have to do with programming? It's Ada, not ADA. (Ada programmers tend to be picky about this.)

I'd write it differently:

with ada.Text_IO;

procedure hello_world is
  Ada.Text_IO.put("Hello World!");
end hello_world;

But this program has you all beat:

Note:  There are no tabs in this file.  Set your line wrap to 80 columns.  Lines must end with
<CR><LF> Save as on a PC to run as an executable.  

Cu  #%* )pop mark/CuG 4 def/# 2 def%%%%@@P[TX---P\P_SXPY!Ex(mx2ex("SX!Ex4P)Ex=
CuG #%*                                                                  *+Ex=
CuG #%*------------------------------------------------------------------*+Ex=
CuG #%*   POLYGLOT - a program in seven languages      15 February 1991  *+Ex=
CuG #%*                                                                  *+Ex=
CuG #%*   Written by Kevin Bungard, Peter Lisle, and Chris Tham          *+Ex=
CuG #%*                                                                  *+Ex=
CuG #%*   We have successfully run this program using the following:     *+Ex=
CuG #%*     ANSI COBOL:            MicroFocus COBOL85 (not COBOL74)      *+Ex=
CuG #%*     ISO  Pascal:           Turbo Pascal (DOS & Mac), Unix PC,    *+Ex=
CuG #%*                            AIX VS Pascal                         *+Ex=
CuG #%*     ANSI Fortran:          Unix f77, AIX VS Fortran              *+Ex=
CuG #%*     ANSI C (lint free):    Microsoft C, Unix CC, GCC, Turbo C++, *+Ex=
CuG #%*                            Think C (Mac)                         *+Ex=
CuG #%*     PostScript:            GoScript, HP/Adobe cartridge,         *+Ex=
CuG #%*                            Apple LaserWriter                     *+Ex=
CuG #%*     Shell script:          gnu bash, sh (SysV, BSD, MKS), ksh    *+Ex=
CuG #%*     8086 machine language: MS-DOS 2.00, 3.03, 4.01, 5.00 beta    *+Ex=
CuG #%*                            VPix & DOS Merge (under unix)         *+Ex=
CuG #%*                            SoftPC (on a Mac), MKS shell          *+Ex=
CuG #%*                                                                  *+Ex=
CuG #%*   Usage:                                                         *+Ex=
CuG #%*     1. Rename this file to polyglot.[cob|pas|f77|c|ps|sh|com]    *+Ex=
CuG #%*     2. Compile and/or run with appropriate compiler and          *+Ex=
CuG #%*        operating system                                          *+Ex=
CuG #%*                                                                  *+Ex=
CuG #%*   Notes:                                                         *+Ex=
CuG #%*     1. We have attempted to use only standard language features. *+Ex=
CuG #%*        Without the -traditional flag gcc will issue a warning.   *+Ex=
CuG #%*                                                                  *+Ex=
CuG #%*     2. This text is a comment block in all seven languages.      *+Ex=
CuG #%*                                                                  *+Ex=
CuG #%*     3. When run as a .COM file with MS-DOS it makes certain      *+Ex=
CuG #%*        (not unreasonable) assumptions about the contents of      *+Ex=
CuG #%*        the registers.                                            *+Ex=
CuG #%*                                                                  *+Ex=
CuG #%*     4. When transfering from Unix to DOS make sure that a LF     *+Ex=
CuG #%*        is correctly translated into a CR/LF.                     *+Ex=
CuG #%*                                                                  *+Ex=
CuG #%*   Please mail any comments, corrections or additions to          *+Ex=
CuG #%*                                       *+Ex=
CuG #%*                                                                  *+Ex=
CuG #%*------------------------------------------------------------------*QuZ=
CuG #%*                                                                  *+Ex=
CuG #(*                                                                  *(
C   # */);                                                              /*(
C   # *)  program        polyglot (output);                             (*+
C   #     identification division.
C   #     program-id.    polyglot.
C   #
C   #     data           division.
C   #     procedure      division.
C   #
C   # * ))cleartomark   /Bookman-Demi findfont 36 scalefont setfont     (
C   # *                                                                 (
C   #
C   # *                  hello polyglots$
C   #     main.
C   #         perform
C     * ) 2>_$$; echo   "hello polyglots"; rm _$$; exit
C             stop run.
     -*,                'hello polyglots'
C         print.
C             display   "hello polyglots".                              (
C     */  int i;                                                        /*
C     */  main () {                                                     /*
C     */      i=printf ("hello polyglots\n"); O= &i; return *O;         /*
C     *)                                                                (*
C     *)  begin                                                         (*
C     *)      writeln  ('hello polyglots');                             (*
C     *)                                                                (* )
C     * ) pop 60 360                                                    (
C     * ) pop moveto    (hello polyglots) show                          (
C     * ) pop showpage                                                  ((
C     *)
           end                                                          .(* )
C)pop%     program       polyglot.                                      *){*/}

Source: alt.msdos.programmer newsgroup (recently posted by Kevin Q. Quitt.):

One more for the chelonians ...

print [Hello World! in Logo]

What does ADA stand for? American Dental Agency? Americans with Disabilities Act? What do they have to do with programming? It's Ada, not ADA. (Ada programmers tend to be picky about this.)

No wonder my dentist looked at me funny when I asked him for the Ada code. Never got the code, but he charged me an extra 55 bucks. Got this code from my barber ...

@ "Hello World! in Clipper"

Another Ada example, actually quite a modern language ...

with Ada.Text_IO;
use Ada.Text_IO;  -- searches Ada.Text_IO
procedure Hello95 is
 Put_Line("Hello world! using Ada95");
end Hello95;

Ada is a high security language and nobly endeavors to reduce mistakes. Does anyone know what Ada stands for?

A contribution from the wild and crazy bunch at BCX basic. Rather than just vapidly coding ...

print "Hello World! in BCX basic"

they want to exercise the old Windows box a little ...

' save hello world to a file
open "hello.txt" for output  as  fp1
  fprint fp1, "Hello World! in bcx basic"
close fp1

' and show it in notepad
run "notepad.exe hello.txt"


Ada is a high security language and nobly endeavors to reduce mistakes. Does anyone know what Ada stands for?

Ada doesn't stand for anything. It's one of the few places in computer science where there's no acryonym... Ada is named after Countess Augusta Ada Lovelace, the first computer programmer.

Way back in my programming days I heard of Ada being named for some lady's first name. I googled for it, but couldn't get the answer. So thanks Puckdropper!

Let's hope the next language is not named after the malady ...

w !,"Hello World! in Mumps"

The Nice language is based on Java, but has adopted some Python features.

void main(String[] args){ 
   println("Hello World! in Nice");

Here's the hello world program in Rain:

Hello, world!

In Boolfuck:


Gah! Did I misread (happens a lot), or did we forget the trusty and classic Visual Basic 6?

Option Explicit
Private Sub Form_Load()
     Print "Hello, World! in VB6"
End Sub

A few examples to show how easy this is to accomplish in Assembly Language:

A) Linux console using GAS:

.global _start
    movl    $4, %eax
    movl    $1, %ebx
    movl    $hello, %ecx
    movl    $14, %edx
    int $0x80

    movl    $1, %eax
    int $0x80

hello:  .string "Hello, world!\n"

ASSEMBLE: as -o hello.o hello.S
LINK: ld -o hello hello.o

B) Linux console using NASM:

; nasm -f elf hw.asm
; ld -s -o hw hw.o

global _start

section code read exec

     mov eax, 4
     mov ebx, 1
     mov ecx, msg
     mov edx, length
     int 80h

     mov eax, 1
     xor ebx, ebx
     int 80h

msg db 'Hello, world!', 10
length equ $ - msg

C) Win32 & Linux console using High Level Assembler (HLA):

program Hello;
#include( "stdlib.hhf" )

begin Hello;

stdout.puts( "Hello, world!" nl );

end Hello;

BUILD: HLA -v Hello

D) Win32 GUI using MASM32:

.model flat, stdcall
option casemap:none
include \masm32\include\
include \masm32\include\
include \masm32\include\
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib

MsgCaption      db "100% ASM Win32 GUI applet",0
MsgBoxText      db "Hello, world!",0

	invoke MessageBox, NULL,addr MsgBoxText, addr MsgCaption, MB_OK
	invoke ExitProcess,NULL
end start


Nice ASM code there Evenbit!

This example is a bit more complex, it allows you to display the familiar text in color on a Windows computer ...

#include <stdio.h> 
#include <windows.h> 

int main(void)
  HANDLE hConsoleOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  WORD wAttributes; 
  CONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo ; 
  // save current text and backgroud colors
  GetConsoleScreenBufferInfo(hConsoleOutput, &lpConsoleScreenBufferInfo);
  wAttributes = lpConsoleScreenBufferInfo.wAttributes; 
  // set new text and background colors
  SetConsoleTextAttribute(hConsoleOutput, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
  printf("Hello world! in colorful C\n");

  // restore origional text and background colors
  SetConsoleTextAttribute(hConsoleOutput, wAttributes);
  getchar();  // wait
  return 0;

Let's write it as a Java Applet ...

import java.applet.Applet;
import java.awt.Graphics;

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

... save it as Helloworld.class and now you can see it in your browser with this HTML code ...

<TITLE> A Hello World Program </TITLE>

Here is the output of the Java applet:
<APPLET CODE="Helloworld.class" WIDTH=150 HEIGHT=25>

Here is a Basic dialect that relies on wx ...

dim wxID_ED = wxID_HIGHEST + 5

// create the main application window
dim frame = new wxFrame( Nothing, -1, "wxBasic", wxPoint(50, 50), wxSize(350, 140))
// create a Text edit control
dim ed = new wxStyledTextCtrl(frame, wxID_ED)

// set the font
dim font = new wxFont(12, wxMODERN, wxNORMAL, wxNORMAL)
ed.StyleSetFont(wxSTC_STYLE_DEFAULT, font)

// set the text
ed.SetText("Hallo World! in wxBasic")

// now show the frame/window

Has anyone tried Rebol yet? The following is a GUI examp for Rebol/View:

REBOL [Title: "HW Example"]

view layout [text "Hello REBOL World!"]


Boo has a syntax similar to Python, has the features of Ruby, and the speed and safety of C#. Boo is a statically-typed language, but fakes being a dynamically-typed language by inference. It runs in the .NET Framework, the code is first translated into MSIL, then into an executable file. Check

print "Hello world!  Using Boo!"

Talking about .NET (Windows) or Mono (Unix) ...

Public Class Hello
  Public Shared Sub Main()
    System.Console.WriteLine("Hello World! Using VB.NET")
  End Sub
End Class

The simplicity of a Boo GUI ...

// a Boo GUI

import System.Windows.Forms from System.Windows.Forms  // Form(), Label()
import System.Drawing from System.Drawing              // Point(), Size(), Color

form1 = Form(Text: "Form with a Label", Size: Size(300, 100), BackColor: Color.Beige)
label1 = Label(Parent: form1, Location: Point(20, 10), Size: Size(270, 20))
label1.Text = "Hello World!  (a Boo GUI program)"



WRITE "Hello World! using ABC language "


print "Hello, World! using Perl language"

Python was supposed to be from ABC and Perl?

Playing with .NET?

.method public static void Main() cil managed
     .maxstack 8
     ldstr "Hello, world! in CIL/MSIL of .NET"
     call void [mscorlib]System.Console::WriteLine(string)
Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.