Hello world/Graphical

In this User Output task, the goal is to display the string "Goodbye, World!" on a GUI object (alert box, plain window, text area, etc.).

[edit] ActionScript

 
var textField:TextField = new TextField();
stage.addChild(textField);
textField.text =  "Goodbye, World!"

[edit] Ada

Library: GTK version GtkAda

Library: GtkAda

with Gdk.Event;   use Gdk.Event;
with Gtk.Label;   use Gtk.Label;
with Gtk.Window;  use Gtk.Window;
with Gtk.Widget;  use Gtk.Widget;
 
with Gtk.Handlers;
with Gtk.Main;
 
procedure Windowed_Goodbye_World is
   Window : Gtk_Window;
   Label  : Gtk_Label;
 
   package Handlers is new Gtk.Handlers.Callback (Gtk_Widget_Record);
   package Return_Handlers is
      new Gtk.Handlers.Return_Callback (Gtk_Widget_Record, Boolean);
 
   function Delete_Event (Widget : access Gtk_Widget_Record'Class)
      return Boolean is
   begin
      return False;
   end Delete_Event;
 
   procedure Destroy (Widget : access Gtk_Widget_Record'Class) is
   begin
     Gtk.Main.Main_Quit;
   end Destroy;
 
begin
   Gtk.Main.Init;
   Gtk.Window.Gtk_New (Window);
   Gtk_New (Label, "Goodbye, World!");
   Add (Window, Label);
   Return_Handlers.Connect
   (  Window,
      "delete_event",
      Return_Handlers.To_Marshaller (Delete_Event'Access)
   );
   Handlers.Connect
   (  Window,
      "destroy",
      Handlers.To_Marshaller (Destroy'Access)
   );
   Show_All (Label);
   Show (Window);
 
   Gtk.Main.Main;
end Windowed_Goodbye_World;

[edit] AppleScript

display dialog "Goodbye, World!" buttons {"Bye"}

[edit] Applesoft BASIC

  1 LET T$ = "GOODBYE, WORLD!"
  2 LET R = 5:GX = 3:GY = 2:O = 3:XC = R + GX:YC = R * 2 + GY
  3 TEXT : HOME : TEXT : HGR : HCOLOR= 7: HPLOT 0,0: CALL 62454: HCOLOR= 6
  4 LET L =  LEN (T$): FOR I = 1 TO L:K =  ASC ( MID$ (T$,I,1)):XO = XC:YO = YC: GOSUB 5:XC = XO + 1:YC = YO: GOSUB 7: NEXT : END 
  5 IF K > 64 THEN K = K + LC: GOSUB 20:LC = 32: RETURN 
  6 LET LC = 0: ON K >  = 32 GOTO 20: RETURN 
  7 GOSUB 20:XC = XC + R * 2 + GX: IF XC > 279 - R THEN XC = R + GX:YC = YC + GY + R * 5
  8 RETURN 
  9 LET XC = XC - R * 2: RETURN 
 10 LET Y = R:D = 1 - R:X = 0
 11 IF D >  = 0 THEN Y = Y - 1:D = D - Y * 2
 12 LET D = D + X * 2 + 3
 13 IF O = 1 OR O = 3 THEN  GOSUB 17
 14 IF O = 2 OR O = 3 THEN  GOSUB 19
 15 LET X = X + 1: IF X < Y THEN 11
 16 LET O = 3:E = 0: RETURN 
 17 HPLOT XC - X,YC + Y: HPLOT XC + X,YC + Y: HPLOT XC - Y,YC + X: IF  NOT E THEN  HPLOT XC + Y,YC + X
 18 RETURN 
 19 HPLOT XC - X,YC - Y: HPLOT XC + X,YC - Y: HPLOT XC - Y,YC - X: HPLOT XC + Y,YC - X: RETURN 
 20 LET M = K - 31
 21 ON M GOTO 32,33,34,35,36,37,38,39,40,41,42,43,44
 22 LET M = M - 32
 23 ON M GOTO 64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87
 24 LET M = M - 32
 25 ON M GOTO 96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,10,112,113,114,115,116,117,118,119,120,121
 32 RETURN 
 33 HPLOT XC - R,YC - R * 2 TO XC - R,YC + R - GY: HPLOT XC - R,YC + R: GOTO 9: REM !
 44 HPLOT XC - R,YC + R + R / 2 TO XC - R,YC + R: GOTO 9: REM ,
 71 LET O = 2:YC = YC - R: GOSUB 10:YC = YC + R: HPLOT XC - R,YC TO XC - R,YC - R: HPLOT XC + R / 2,YC TO XC + R,YC TO XC + R,YC + R:O = 1: GOTO 10: REM G
 87 HPLOT XC - R,YC - R * 2 TO XC - R,YC + R TO XC,YC TO XC + R,YC + R TO XC + R,YC - R * 2: RETURN : REM W
 98 HPLOT XC - R,YC - R * 2 TO XC - R,YC + R: GOTO 10: RETURN : REM B
100 HPLOT XC + R,YC - R * 2 TO XC + R,YC + R: GOTO 10: REM D
101 HPLOT XC - R,YC TO XC + R,YC:E = 1: GOTO 10: REM E
108 HPLOT XC - R,YC - R * 2 TO XC - R,YC + R: GOTO 9: REM L
114 HPLOT XC - R,YC - R TO XC - R,YC + R:O = 2: GOTO 10: REM R
121 HPLOT XC - R,YC - R TO XC,YC + R: HPLOT XC + R,YC - R TO XC - R,YC + R * 3: RETURN : REM Y

[edit] ATS

%{^
extern
ats_void_type
mainats (ats_int_type argc, ats_ptr_type argv);
%}
 
staload "contrib/glib/SATS/glib.sats"
staload "contrib/glib/SATS/glib-object.sats"
staload "contrib/GTK/SATS/gtk.sats"
 
extern fun main1 (): void = "main1"
 
implement main1 () = () where {
  val window = gtk_window_new (GTK_WINDOW_TOPLEVEL)
  val (pf | title) = gstring_of_string ("Goodbye, World!")
  val () = gtk_window_set_title (window, title)
  prval () = pf (title)
  val _sid = g_signal_connect
    (window, (gsignal)"delete-event", (G_CALLBACK)gtk_main_quit, (gpointer)null)
  val () = gtk_widget_show (window)
  val () = gtk_main ()
  val () = gtk_widget_destroy0 (window)
}
 
implement main_dummy () = ()
 
%{$
ats_void_type
mainats (ats_int_type argc, ats_ptr_type argv)
{
  gtk_init ((int*)&argc, (char***)&argv);
  main1 ();
  return;
}
%}

[edit] AutoHotkey

MsgBox, Goodbye`, World!

ToolTip, Goodbye`, World!

Gui, Add, Text,   x4    y4,   To be announced:
Gui, Add, Edit,   xp+90 yp-3, Goodbye, World!
Gui, Add, Button, xp+98 yp-1, OK
Gui, Show, w226 h22	    , Rosetta Code
Return

SplashTextOn, 100, 100, Rosetta Code, Goodbye, World!

[edit] AutoIt

; display a window
$hMain = GUICreate("Hello World", 178, 125)
GUICtrlCreateLabel("Goodbye, world", 48, 48, 78, 17)
GUISetState()
While GUIGetMsg() <> -3
WEnd
GUIDelete($hMain)
;a message box
MsgBox(0, "", "Goodbye, world")

MsgBox(0,"Goodbye","Goodbye, World!")

ToolTip("Goodbye, World!")

[edit] BASIC

Works with: FreeBASIC

' Demonstrate a simple Windows application using FreeBasic
 
#include once "windows.bi"
 
Declare Function WinMain(ByVal hInst As HINSTANCE, _
      ByVal hPrev As HINSTANCE, _
      ByVal szCmdLine as String, _
      ByVal iCmdShow As Integer) As Integer
End WinMain( GetModuleHandle( null ), null, Command( ), SW_NORMAL )
 
Function WinMain (ByVal hInst As HINSTANCE, _
                  ByVal hPrev As HINSTANCE, _
                  ByVal szCmdLine As String, _
                  ByVal iCmdShow As Integer) As Integer
    MessageBox(NULL, "Goodbye World", "Goodbye World", MB_ICONINFORMATION)
    function = 0
End Function

' Demonstrate a simple Windows/Linux application using GTK/FreeBasic
 
#INCLUDE "gtk/gtk.bi"
 
gtk_init(@__FB_ARGC__, @__FB_ARGV__)
 
VAR win = gtk_window_new (GTK_WINDOW_TOPLEVEL)
gtk_window_set_title (gtk_window (win), "Goodbye, World")
g_signal_connect(G_OBJECT (win), "delete-event", @gtk_main_quit, 0)
gtk_widget_show_all (win)
 
gtk_main()
 
END 0

[edit] BASIC256

clg
font "times new roman", 20,100
color orange
rect 10,10, 140,30
color red
text 10,10, "Hello World"

[edit] BBC BASIC

Works with: BBC BASIC for Windows

      SYS "MessageBox", @hwnd%, "Goodbye, World!", "", 0

[edit] C

Library: GTK

#include <gtk/gtk.h>
 
int main (int argc, char **argv) {
  GtkWidget *window;
  gtk_init(&argc, &argv);
 
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window), "Goodbye, World");
  g_signal_connect (G_OBJECT (window), "delete-event", gtk_main_quit, NULL);
  gtk_widget_show_all (window);
 
  gtk_main();
  return 0;
}

Library: Win32

Where hWnd is a valid window handle corresponding to a control in the application

#include "windows.h"
void SayGoodbyeWorld(HWND hWnd)
{
  SetWindowText(hWnd, _T("Goodbye, World!"));
}

[edit] C#

Library: Windows Forms

using System;
using System.Windows.Forms;
 
class Program {
    static void Main(string[] args) {
        Application.EnableVisualStyles(); //Optional.
        MessageBox.Show("Hello World!");
    }
}

Library: GTK

using Gtk;
using GtkSharp;
 
public class GoodbyeWorld {
  public static void Main(string[] args) {
    Gtk.Window window = new Gtk.Window();
    window.Title = "Goodbye, World";
    window.DeleteEvent += delegate { Application.Quit(); };
    window.ShowAll();
    Application.Run();
  }
}

[edit] C++

Works with: GCC version 3.3.5

Library: GTK

#include <gtkmm.h>
int main(int argc, char *argv[])
{
   Gtk::Main app(argc, argv);
   Gtk::MessageDialog msg("Goodbye, World!");
   msg.run();
}

Library: Win32

All Win32 APIs work in C++ the same way as they do in C. See the C example.

Library: MFC

Where pWnd is a pointer to a CWnd object corresponding to a valid window in the application.

#include "afx.h"
void ShowGoodbyeWorld(CWnd* pWnd)
{
    pWnd->SetWindowText(_T("Goodbye, World!"));
}

Library: FLTK

 
#include <FL/Fl.H>
#include <FL/Fl_Window.H>
#include <FL/Fl_Box.H>
 
int main(int argc, char **argv) {
  Fl_Window *window = new Fl_Window(300,180);
  Fl_Box *box = new Fl_Box(20,40,260,100,"Goodby, World!");
  box->box(FL_UP_BOX);
  box->labelsize(36);
  box->labelfont(FL_BOLD+FL_ITALIC);
  box->labeltype(FL_SHADOW_LABEL);
  window->end();
  window->show(argc, argv);
  return Fl::run();
}

[edit] C++/CLI

 
using namespace System::Windows::Forms;
 
int main(array<System::String^> ^args)
{
  MessageBox::Show("Goodbye, World!", "Rosetta Code");
}

[edit] Clean

Library: Object I/O

import StdEnv, StdIO
 
Start :: *World -> *World
Start world = startIO NDI Void (snd o openDialog undef hello) [] world
where
    hello = Dialog "" (TextControl "Goodbye, World!" []) 
                                     [WindowClose (noLS closeProcess)]

[edit] Clojure

(ns experimentation.core
  (:import (javax.swing JOptionPane JFrame JTextArea JButton)
	   (java.awt FlowLayout)))
 
(JOptionPane/showMessageDialog nil "Goodbye, World!")
(let [button (JButton. "Goodbye, World!")
      window (JFrame. "Goodbye, World!")
      text (JTextArea. "Goodbye, World!")]
  (doto window
    (.setLayout (FlowLayout.))
    (.add button)
    (.add text)
    (.pack)
    (.setDefaultCloseOperation (JFrame/EXIT_ON_CLOSE))
    (.setVisible true)))

[edit] COBOL

This is a TUI, not a GUI version, because it

Works with: OpenCOBOL 1.1

The program gets the lines and columns of the screen and positions the text in the middle. Program waits for a return key.

	program-id. ghello.
	data division.
	working-storage section.
	01	var	pic x(1).
	01	lynz	pic 9(3).
	01 	colz	pic 9(3).
	01	msg	pic x(15) value "Goodbye, world!".
	procedure division.
		accept lynz from lines end-accept
		divide lynz by 2 giving lynz.
		accept colz from columns end-accept
		divide colz by 2 giving colz.
		subtract 7 from colz giving colz.
		display msg
			at line number lynz 
			column number colz 
		end-display
		accept var end-accept
		stop run.

[edit] Cobra

Requires

Library: GTK#

GUI library.

 
@args -pkg:gtk-sharp-2.0
 
use Gtk
 
class MainProgram
	def main
		Application.init
		dialog = MessageDialog(nil,
			DialogFlags.DestroyWithParent,
			MessageType.Info, 
			ButtonsType.Ok,
			"Goodbye, World!")
		dialog.run
		dialog.destroy

[edit] CoffeeScript

alert "Goodbye, World!"

[edit] Common Lisp

This can be done using the extension package ltk that provides an interface to the Tk library.

Library: Tk

(use-package :ltk)
 
(defun show-message (text)
  "Show message in a label on a Tk window"
  (with-ltk ()
      (let* ((label (make-instance 'label :text text))
             (button (make-instance 'button :text "Done"
                                    :command (lambda () 
                                               (ltk::break-mainloop)
                                               (ltk::update)))))
              (pack label :side :top :expand t :fill :both)
              (pack button :side :right)
              (mainloop))))
 
(show-message "Goodbye World")

[edit] Creative Basic

 
DEF Win:WINDOW
DEF Close:CHAR
DEF ScreenSizeX,ScreenSizeY:INT
 
GETSCREENSIZE(ScreenSizeX,ScreenSizeY)
 
WINDOW Win,0,0,ScreenSizeX,ScreenSizeY,0,0,"Goodbye program",MainHandler
 
PRINT Win,"Goodbye, World!"
'Prints in the upper left corner of the window (position 0,0).
 
WAITUNTIL Close=1
 
CLOSEWINDOW Win
 
END
 
SUB MainHandler
 
    IF @CLASS=@IDCLOSEWINDOW THEN Close=1   
 
RETURN

[edit] D

Library: gtkD

import gtk.MainWindow, gtk.Label, gtk.Main;
 
class GoodbyeWorld : MainWindow {
    this() {
        super("GtkD");
        add(new Label("Goodbye World"));
        showAll();
    }
}
 
void main(string[] args) {
    Main.init(args);
    new GoodbyeWorld();
    Main.run();
}

[edit] Delphi

program HelloWorldGraphical;
 
uses
  Dialogs;
 
begin
  ShowMessage('Goodbye, World!');
end.

[edit] Dylan

(This works entered into the interactive shell):

notify-user("hello world!", frame: make(<frame>));

[edit] E

Library: SWT

This is a complete application. If it were part of a larger application, the portions related to interp would be removed.

def <widget> := <swt:widgets.*>
def SWT := <swt:makeSWT>
 
def frame := <widget:makeShell>(currentDisplay)
  frame.setText("Rosetta Code")
  frame.setBounds(30, 30, 230, 60)
  frame.addDisposeListener(def _ { to widgetDisposed(event) {
    interp.continueAtTop()
  }})
 
def label := <widget:makeLabel>(frame, SWT.getLEFT())
  label.setText("Goodbye, World!")
  swtGrid`$frame: $label`
 
frame.open()
 
interp.blockAtTop()

[edit] eC

MessageBox:

import "ecere"
MessageBox goodBye { contents = "Goodbye, World!" };

Label:

import "ecere"
Label label { text = "Goodbye, World!", hasClose = true, opacity = 1, size = { 320, 200 } };

Titled Form + Surface Output:

import "ecere"
 
class GoodByeForm : Window
{
   text = "Goodbye, World!";
   size = { 320, 200 };
   hasClose = true;
 
   void OnRedraw(Surface surface)
   {
      surface.WriteTextf(10, 10, "Goodbye, World!");
   }
}
 
GoodByeForm form {};

[edit] Euphoria

[edit] Message box

include msgbox.e
 
integer response
response = message_box("Goodbye, World!","Bye",MB_OK)

[edit] EGL

Works with: EDT

Allows entry of any name into a text field (using "World" as the default entry). Then, when the "Say Goodbye" button is pressed, sets a text label to the value "Goodbye, <name>!".

 
import org.eclipse.edt.rui.widgets.*;
import dojo.widgets.*;
 
handler HelloWorld type RUIhandler{initialUI =[ui]}
 
    ui Box {columns=1, children=[nameField, helloLabel, goButton]};
 
    nameField DojoTextField {placeHolder = "What's your name?", text = "World"};
    helloLabel TextLabel {};
    goButton DojoButton {text = "Say Goodbye", onClick ::= onClick_goButton};
 
    function onClick_goButton(e Event in) 
        helloLabel.text = "Goodbye, " + nameField.text + "!";
    end
 
end

[edit] F#

Just display the text in a message box.

#light
open System
open System.Windows.Forms
[<EntryPoint>]
let main _ =
    MessageBox.Show("Hello World!") |> ignore
    0

[edit] Factor

To be pasted in the listener :

   USING: ui ui.gadgets.labels
   [ "Goodbye World" <label> "Rosetta Window" open-window ] with-ui

[edit] Fantom

 
using fwt
 
class Hello
{
  public static Void main ()
  {
    Dialog.openInfo (null, "Goodbye world")
  }
}

[edit] Forth

Works with: SwiftForth

HWND z" Goodbye, World!" z" (title)" MB_OK MessageBox

[edit] Frink

All Frink graphics are automatically scaled and centered in the window, so the exact coordinates used below are rather arbitrary.

 
g = new graphics
g.font["SansSerif", 10]
g.text["Hello World!", 0, 0]
g.show[]
 
g.print[]                           // Optional: render to printer
g.write["HelloWorld.png", 400, 300] // Optional: write to graphics file

[edit] Gambas

Message.Info("Goodbye, World!")    ' Display a simple message box

[edit] Go

Library: go-gtk

package main
 
import "github.com/mattn/go-gtk/gtk"
 
func main() {
   gtk.Init(nil)
   win := gtk.Window(gtk.GTK_WINDOW_TOPLEVEL)
   win.SetTitle("Goodbye, World!")
   win.SetSizeRequest(300, 200)
   win.Connect("destroy", gtk.MainQuit)
   button := gtk.ButtonWithLabel("Goodbye, World!")
   win.Add(button)
   button.Connect("clicked", gtk.MainQuit)
   win.ShowAll()
   gtk.Main()
}

[edit] Groovy

Translation of: Java

import groovy.swing.SwingBuilder
import javax.swing.JFrame
 
new SwingBuilder().edt {
  optionPane().showMessageDialog(null, "Goodbye, World!")
  frame(title:'Goodbye, World!', defaultCloseOperation:JFrame.EXIT_ON_CLOSE, pack:true, show: true) {
    flowLayout()
    button(text:'Goodbye, World!')
    textArea(text:'Goodbye, World!')
  }
}

[edit] GUISS

Here we display the message on the system notepad:

Start,Programs,Accessories,Notepad,Type:Goodbye[comma][space]World[pling]

[edit] Haskell

Using

Library: gtk

from HackageDB

import Graphics.UI.Gtk
import Control.Monad
 
messDialog = do
  initGUI
  dialog <- messageDialogNew Nothing [] MessageInfo ButtonsOk "Goodbye, World!"
 
  rs <- dialogRun dialog
  when (rs == ResponseOk || rs == ResponseDeleteEvent) $ widgetDestroy dialog
 
  dialog `onDestroy` mainQuit
 
  mainGUI

Run in GHCi interpreter:

*Main> messDialog

[edit] HicEst

WRITE(Messagebox='!') 'Goodbye, World!'

[edit] Icon and Unicon

[edit] Icon

link graphics
procedure main() 
   WOpen("size=100,20") | stop("No window")
   WWrites("Goodbye, World!")
   WDone()
end

Library: Icon Programming Library

graphics is required

[edit] Unicon

 
import gui
$include "guih.icn"
 
class WindowApp : Dialog ()
 
  # -- automatically called when the dialog is created
  method component_setup ()
    # add 'hello world' label
    label := Label("label=Hello world","pos=0,0")
    add (label)
 
    # make sure we respond to close event
    connect(self, "dispose", CLOSE_BUTTON_EVENT)
  end
end
 
# create and show the window
procedure main ()
  w := WindowApp ()
  w.show_modal ()
end

[edit] Integer BASIC

40×40 isn't great resolution, but it's enough!

 
10 REM FONT DERIVED FROM 04B-09 BY YUJI OSHIMOTO
20 GR
30 COLOR = 12
40 REM G
50 HLIN 0,5 AT 0 : HLIN 0,5 AT 1
60 VLIN 2,9 AT 0 : VLIN 2,9 AT 1
70 HLIN 2,5 AT 9 : HLIN 2,5 AT 8
80 VLIN 4,7 AT 5 : VLIN 4,7 AT 4
90 VLIN 4,5 AT 3
100 REM O
110 HLIN 7,12 AT 2 : HLIN 7,12 AT 3
120 HLIN 7,12 AT 8 : HLIN 7,12 AT 9
130 VLIN 4,7 AT 7 : VLIN 4,7 AT 8
140 VLIN 4,7 AT 11 : VLIN 4,7 AT 12
150 REM O
160 HLIN 14,19 AT 2 : HLIN 14,19 AT 3
170 HLIN 14,19 AT 8 : HLIN 14,19 AT 9
180 VLIN 4,7 AT 14 : VLIN 4,7 AT 15
190 VLIN 4,7 AT 18 : VLIN 4,7 AT 19
200 REM D
210 HLIN 21,24 AT 2 : HLIN 21,24 AT 3
220 HLIN 21,26 AT 8 : HLIN 21,26 AT 9
230 VLIN 4,7 AT 21 : VLIN 4,7 AT 22
240 VLIN 0,7 AT 25 : VLIN 0,7 AT 26
250 REM -
260 HLIN 28,33 AT 4 : HLIN 28,33 AT 5
270 REM B
280 VLIN 11,20 AT 0 : VLIN 11,20 AT 1
290 HLIN 2,5 AT 20 : HLIN 2,5 AT 19
300 VLIN 15,18 AT 5 : VLIN 15,18 AT 4
310 HLIN 2,5 AT 14 : HLIN 2,5 AT 13
320 REM Y
330 VLIN 13,20 AT 7 : VLIN 13,20 AT 8
340 VLIN 19,20 AT 9 : VLIN 19,20 AT 10
350 VLIN 13,24 AT 11 : VLIN 13,24 AT 12
360 VLIN 23,24 AT 10 : VLIN 23,24 AT 9
370 REM E
380 VLIN 13,20 AT 14 : VLIN 13,20 AT 15
390 HLIN 16,19 AT 13 : HLIN 16,19 AT 14
400 HLIN 18,19 AT 15 : HLIN 18,19 AT 16
410 HLIN 16,17 AT 17 : HLIN 16,17 AT 18
420 HLIN 16,19 AT 19 : HLIN 16,19 AT 20
430 REM ,
440 VLIN 17,22 AT 21 : VLIN 17,22 AT 22
450 REM W
460 VLIN 24,33 AT 0 : VLIN 24,33 AT 1 : VLIN 24,33 AT 3
470 VLIN 24,33 AT 4 : VLIN 24,33 AT 6 : VLIN 24,33 AT 7
480 HLIN 0,7 AT 33 : HLIN 0,7 AT 32
490 REM O
500 HLIN 9,14 AT 26 : HLIN 9,14 AT 27
510 HLIN 9,14 AT 32 : HLIN 9,14 AT 33
520 VLIN 28,31 AT 9 : VLIN 28,31 AT 10
530 VLIN 28,31 AT 13 : VLIN 28,31 AT 14
540 REM R
550 HLIN 16,21 AT 26 : HLIN 16,21 AT 27
560 VLIN 28,33 AT 16 : VLIN 28,33 AT 17
570 REM L
580 VLIN 24,33 AT 23 : VLIN 24,33 AT 24
590 REM D
600 HLIN 26,29 AT 26 : HLIN 26,29 AT 27
610 HLIN 26,29 AT 32 : HLIN 26,29 AT 33
620 VLIN 28,33 AT 26 : VLIN 28,33 AT 27
630 VLIN 24,33 AT 30 : VLIN 24,33 AT 31
640 REM !
650 VLIN 24,29 AT 33 : VLIN 24,29 AT 34
660 VLIN 32,33 AT 33 : VLIN 32,33 AT 34
670 END

[edit] Ioke

Translation of: Java

import(
  :javax:swing, :JOptionPane, :JFrame, :JTextArea, :JButton
)
import java:awt:FlowLayout
 
JOptionPane showMessageDialog(nil, "Goodbye, World!")
button = JButton new("Goodbye, World!")
text = JTextArea new("Goodbye, World!")
window = JFrame new("Goodbye, World!") do(
  layout = FlowLayout new
  add(button)
  add(text)
  pack
  setDefaultCloseOperation(JFrame field:EXIT_ON_CLOSE)
  visible = true
)

[edit] IWBASIC

 
DEF Win:WINDOW
DEF Close:CHAR
DEF ScreenSizeX,ScreenSizeY:UINT
 
GETSCREENSIZE(ScreenSizeX,ScreenSizeY)
 
OPENWINDOW Win,0,0,ScreenSizeX,ScreenSizeY,NULL,NULL,"Goodbye program",&MainHandler
 
PRINT Win,"Goodbye, World!"
'Prints in upper left corner of the window (position 0,0).
 
WAITUNTIL Close=1
 
CLOSEWINDOW Win
 
END
 
SUB MainHandler
 
    IF @MESSAGE=@IDCLOSEWINDOW THEN Close=1
 
RETURN
ENDSUB

[edit] J

(for versions of J prior to the current - 7.01)

wdinfo'Goodbye, World!'

[edit] Java

Library: Swing

import javax.swing.*;
import java.awt.*;
 
public class OutputSwing {
 
    public static void main(String[] args) {
 
        SwingUtilities.invokeLater(new Runnable(){
            public void run() {
                JOptionPane.showMessageDialog (null, "Goodbye, World!"); // in alert box
                JFrame frame = new JFrame("Goodbye, World!");            // on title bar
                JTextArea text = new JTextArea("Goodbye, World!");       // in editable area
                JButton button = new JButton("Goodbye, World!");         // on button
 
                frame.setLayout(new FlowLayout());
                frame.add(button);
                frame.add(text);
                frame.pack();
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            }
        });
    }
}

[edit] JavaScript

 alert("Goodbye, World!");

[edit] Just Basic

 
print "Goodbye, World!"
'Prints in the upper left corner of the default text window: mainwin, a window with scroll bars.

[edit] KonsolScript

Popping a dialog-box.

function main() {
  Konsol:Message("Goodbye, World!", "")
}

Displaying it in a Window.

function main() {
  Screen:PrintString("Goodbye, World!")
  while (B1 == false) {
    Screen:Render()
  }
}

This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

[edit] Liberty BASIC

NOTICE "Goodbye, world!"

[edit] Logo

Works with: UCB Logo

Among the turtle commands are some commands for drawing text in the graphical area. Details and capabilities differ among Logo implementations.

LABEL [Hello, World!]
SETLABELHEIGHT 2 * last LABELSIZE
LABEL [Goodbye, World!]

[edit] Lua

require "iuplua"
 
dlg = iup.dialog{iup.label{title="Goodbye, World!"}; title="test"}
dlg:show()
 
if (not iup.MainLoopLevel or iup.MainLoopLevel()==0) then
  iup.MainLoop()
end

[edit] Maple

 
Maplets:-Display( Maplets:-Elements:-Maplet( [ "Goodbye, World!" ] ) );

[edit] Mathematica

CreateDialog["Hello world"]

[edit] MATLAB

msgbox('Goodbye, World!')

Add text to a graphical plot.

 text(0.2,0.2,'Hello World!')

[edit] MAXScript

messageBox "Goodbye world"

[edit] mIRC Scripting Language

alias goodbyegui {
  dialog -m Goodbye Goodbye
}
 
dialog Goodbye {
  title "Goodbye, World!"
  size -1 -1 80 20
  option dbu
  text "Goodbye, World!", 1, 20 6 41 7
}

[edit] Modula-3

Library: Trestle

MODULE GUIHello EXPORTS Main;
 
IMPORT TextVBT, Trestle;
 
<*FATAL ANY*>
 
VAR v := TextVBT.New("Goodbye, World!");
 
BEGIN
  Trestle.Install(v);
  Trestle.AwaitDelete(v);
END GUIHello.

This code requires an m3makefile.

import ("ui")
implementation ("GUIHello")
program ("Hello")

This tells the compiler to link with the UI library, the file name of the implementation code, and to output a program named "Hello".

[edit] Nemerle

Compile with:

ncc -reference:System.Windows.Forms goodbye.n

using System;
using System.Windows.Forms;
 
MessageBox.Show("Goodbye, World!")

[edit] NetRexx

Using Java's Swing Foundation Classes.

Library: Swing

/* NetRexx */
options replace format comments java crossref symbols binary
 
import javax.swing.
 
msgText = 'Goodbye, World!'
JOptionPane.showMessageDialog(null, msgText)

An alternative version using other Swing classes.

Library: Swing

/* NetRexx */
options replace format comments java crossref symbols binary
 
import javax.swing.
 
msgText = 'Goodbye, World!'
 
window = JFrame(msgText)
text = JTextArea()
minSize = Dimension(200, 100)
 
text.setText(msgText)
 
window.setLayout(FlowLayout())
window.add(text)
window.setMinimumSize(minSize)
window.pack
window.setVisible(isTrue)
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
 
return
 
method isTrue() public static returns boolean
  return 1 == 1
 
method isFalse() public static returns boolean
  return \isTrue

An example using Java's Abstract Window Toolkit (AWT)

Library: AWT

/* NetRexx */
options replace format comments java crossref symbols binary
 
class RCHelloWorld_GraphicalAWT_01 extends Dialog implements ActionListener
 
  properties private constant
    msgText = 'Goodbye, World!'
 
  properties indirect
    ok = boolean
    can = boolean
    okButton = Button
    canButton = Button
    buttonPanel = Panel
 
method RCHelloWorld_GraphicalAWT_01(frame = Frame, msg = String, canaction = boolean) public
  super(frame, 'Default', isTrue)
  setLayout(BorderLayout())
  add(BorderLayout.CENTER, Label(msg))
  addOKCancelPanel(canaction)
  createFrame()
  pack()
  setVisible(isTrue)
 
  return
 
method RCHelloWorld_GraphicalAWT_01(frame = Frame, msg = String) public
  this(frame, msg, isFalse)
  return
 
method addOKCancelPanel(canaction = boolean)
  setButtonPanel(Panel())
  getButtonPanel.setLayout(FlowLayout())
  createOKButton()
  if canaction then do
    createCancelButton()
    end
  add(BorderLayout.SOUTH, getButtonPanel)
  return
 
method createOKButton()
  setOkButton(Button('OK'))
  getButtonPanel.add(getOkButton)
  getOkButton.addActionListener(this)
  return
 
method createCancelButton()
  setCanButton(Button('Cancel'))
  getButtonPanel.add(getCanButton)
  getCanButton.addActionListener(this)
  return
 
method createFrame()
  dim = getToolkit().getScreenSize
  setLocation(int(dim.width / 3), int(dim.height / 3))
  return
 
method actionPerformed(ae = ActionEvent) public
  if ae.getSource == getOkButton then do
    setOk(isTrue)
    setCan(isFalse)
    setVisible(isFalse)
    end
  else if ae.getSource == getCanButton then do
    setCan(isTrue)
    setOk(isFalse)
    setVisible(isFalse)
    end
  return
 
method main(args = String[]) public constant
  mainFrame = Frame()
  mainFrame.setSize(200, 200)
  mainFrame.setVisible(isTrue)
  message = RCHelloWorld_GraphicalAWT_01(mainFrame, msgText, isTrue)
  if message.isOk then
    say 'OK pressed'
  if message.isCan then
    say 'Cancel pressed'
  message.dispose
  mainFrame.dispose
  return
 
method isTrue() public static returns boolean
  return 1 == 1
 
method isFalse() public static returns boolean
  return \isTrue

[edit] newLISP

NewLISP uses a lightweight Java GUI server that it communicates with over a pipe, similar how some languages use Tcl/Tk. This takes advantage of Java's cross platform GUI capability.

; hello-gui.lsp
; oofoe 2012-01-18
 
; Initialize GUI server.
(load (append (env "NEWLISPDIR") "/guiserver.lsp"))
(gs:init)
 
; Create window frame.
(gs:frame 'Goodbye 100 100 300 200 "Goodbye!")
(gs:set-resizable 'Goodbye nil)
(gs:set-flow-layout 'Goodbye "center")
 
; Add final message.
(gs:label 'Message "Goodbye, World!" "center")
(gs:add-to 'Goodbye 'Message)
 
; Show frame.
(gs:set-visible 'Goodbye true)
 
; Start event loop.
(gs:listen)
 
(exit) ; NewLisp normally goes to listener after running script.

[edit] Objective-C

To show a modal alert (Mac):

NSAlert *alert = [[[NSAlert alloc] init] autorelease];
[alert setMessageText:@"Goodbye, World!"];
[alert runModal];

To show a modal alert (iOS):

UIAlertView *alert = [[[UIAlertView alloc] initWithTitle:@"Goodbye, World!" message:nil delegate:nil cancelButtonTitle:@"OK" otherButtonTitles:nil] autorelease];
[alert show];

[edit] Objeck

Library: Qt

 
use Qt;
 
bundle Default {
  class QtExample {
    function : Main(args : String[]) ~ Nil {
      app := QAppliction->New();
      win := QWidget->New();
      win->Resize(400, 300);
      win->SetWindowTitle("Goodbye, World!");
      win->Show();
      app->Exec();
      app->Delete();
    }
  }
}

[edit] OCaml

Library: GTK

let delete_event evt = false
 
let destroy () = GMain.Main.quit ()
 
let main () =
  let window = GWindow.window in
  let _ = window#set_title "Goodbye, World" in
  let _ = window#event#connect#delete ~callback:delete_event in
  let _ = window#connect#destroy ~callback:destroy in
  let _ = window#show () in
  GMain.Main.main ()
;;
 
let _ = main () ;;

Library: OCaml-Xlib

Simple window with OCaml and Xlib

Library: Tk

ocaml -I +labltk labltk.cma

Just output as a label in a window:

let () =
  let main_widget = Tk.openTk () in
  let lbl = Label.create ~text:"Goodbye, World" main_widget in
  Tk.pack [lbl];
  Tk.mainLoop();;

Output as text on a button that exits the current application:

let () =
  let action () = exit 0 in
  let main_widget = Tk.openTk () in
  let bouton_press =
    Button.create main_widget ~text:"Goodbye, World" ~command:action in
  Tk.pack [bouton_press];
  Tk.mainLoop();;

[edit] OxygenBasic

Windows MessageBox:


print "Hello World!"

[edit] Oxygene

[edit] Glade

Requires a Glade GUI description file. 'ere be one I produced earlier:

 
<?xml version="1.0" standalone="no"?> <!--*- mode: xml -*-->
<!DOCTYPE glade-interface SYSTEM "http://glade.gnome.org/glade-2.24.dtd">
 
<glade-interface>
 
<widget class="GtkWindow" id="hworld">
  <property name="visible">True</property>
  <property name="title">Hello World</property>
  <property name="modal">False</property>
  <property name="resizable">True</property>
  <property name="default_width">200</property>
  <property name="default_height">100</property>
  <signal name="delete_event" handler="on_hworld_delete_event"/>
  <child>
    <widget class="GtkLabel" id="label1">
      <property name="visible">True</property>
      <property name="can_focus">False</property>
      <property name="label" translatable="yes">Farewell, cruel world.</property>
    </widget>
  </child>
</widget>
 
</glade-interface>

And finally the Oxygene:

 
// Display a Message in a GUI Window
//
// Nigel Galloway, April 18th., 2012.
//
namespace HelloWorldGUI;
 
interface
 
uses
  Glade, Gtk, System;
 
type
  Program = public static class
  public
    class method Main(args: array of String);
  end;
 
  MainForm = class(System.Object)
  private
    var
      [Widget] hworld: Gtk.Window;
  public
    constructor(args: array of String);
    method on_hworld_delete_event(aSender: Object; args: DeleteEventArgs);
  end;
 
implementation
 
class method Program.Main(args: array of String);
begin
  new MainForm(args);
end;
 
constructor MainForm(args: array of String);
begin
  inherited constructor;
  Application.Init();
  with myG := new Glade.XML(nil, 'HelloWorldGUI.Main.glade', 'hworld', nil) do myG.Autoconnect(self);
  Application.Run();
end;
 
method MainForm.on_hworld_delete_event(aSender: Object; args: DeleteEventArgs);
begin
  Application.Quit();
end;
 
end.

[edit] .NET

 
namespace HelloWorldNET;
 
interface
 
type
  App = class
  public
    class method Main;
  end;
 
implementation
 
class method App.Main;
begin
  System.Windows.MessageBox.Show("Farewell cruel world");
end;
 
end.

[edit] Oz

declare
  [QTk] = {Module.link ['x-oz://system/wp/QTk.ozf']}
  Window = {QTk.build td(label(text:"Goodbye, World!"))}
in
  {Window show}

[edit] OpenEdge/Progress

MESSAGE "Goodbye, World!" VIEW-AS ALERT-BOX.

[edit] Panoramic

print "Goodbye, World!"
'Prints in the upper left corner of the window.

[edit] Pascal

Works with: Free_Pascal

Library: Gtk2

Variant of the C example:

program HelloWorldGraphical;
 
uses
  glib2, gdk2, gtk2;
 
var
  window: PGtkWidget;
 
begin
  gtk_init(@argc, @argv);
 
  window := gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
  gtk_window_set_title (GTK_WINDOW (window), 'Goodbye, World');
  g_signal_connect (G_OBJECT (window), 
                    'delete-event',
		    G_CALLBACK (@gtk_main_quit),
		    NULL);
  gtk_widget_show_all (window);
 
  gtk_main();
end.

[edit] Perl

Works with: Perl version 5.8.8

Library: Tk

Just output as a label in a window:

 
use strict;
use warnings;
use Tk;
 
my $main = MainWindow->new;
$main->Label(-text => 'Goodbye, World')->pack;
MainLoop();

Output as text on a button that exits the current application:

use strict;
use warnings;
use Tk;
 
my $main = MainWindow->new;
$main->Button(
  -text => 'Goodbye, World',
  -command => \&exit,
)->pack;
MainLoop();

Library: Gtk2

use strict;
use warnings;
use Gtk2 '-init';
 
my $window = Gtk2::Window->new;
$window->set_title('Goodbye world');
$window->signal_connect(
  destroy => sub { Gtk2->main_quit; }
);
 
my $label = Gtk2::Label->new('Goodbye, world');
$window->add($label);
 
$window->show_all;
Gtk2->main;

Library: XUL::Gui Gui

use strict;
use warnings;
use XUL::Gui;
 
display Label 'Goodbye, World!';

use strict;
use warnings;
use XUL::Gui;
 
display Button
    label => 'Goodbye, World!',
    oncommand => sub {quit};

[edit] Perl 6

Works with: niecza

Library: Gtk#

# Translated from http://www.mono-project.com/GtkSharp:_Hello_World
 
constant $GTK = "gtk-sharp,Version=2.12.0.0,Culture=neutral,PublicKeyToken=35e10195dab3c99f";
 
constant Application = CLR::("Gtk.Application,$GTK");
constant Window      = CLR::("Gtk.Window,$GTK");
constant Button      = CLR::("Gtk.Button,$GTK");
 
Application.Init;
 
# Set up a button object.
my $btn = Button.new("Goodbye, World!");
$btn.add_Clicked: sub ($obj, $args) { #OK
    # runs when the button is clicked.
    say "Goodbye, World!";
    Application.Quit;
};
 
my $window = Window.new("goodbyeworld");
$window.add_DeleteEvent: sub ($obj, $args) { #OK
    # runs when the user deletes the window using the "close
    # window" widget in the window frame.
    Application.Quit;
};
 
# Add the button to the window and display everything
$window.Add($btn);
$window.ShowAll;
 
Application.Run;

[edit] PHP

Library: PHP-GTK

if (!class_exists('gtk')) 
{
    die("Please load the php-gtk2 module in your php.ini\r\n");
}
 
$wnd = new GtkWindow();
$wnd->set_title('Goodbye world');
$wnd->connect_simple('destroy', array('gtk', 'main_quit'));
 
$lblHello = new GtkLabel("Goodbye, World!");
$wnd->add($lblHello);
 
$wnd->show_all();
Gtk::main();

[edit] PicoLisp

(call 'dialog "--msgbox" "Goodbye, World!" 5 20)

[edit] PostScript

In the general Postscript context, the show command will render the string that is topmost on the stack at the currentpoint in the previously setfont. Thus a minimal PostScript file that will print on a PostScript printer or previewer might look like this:

%!PS
% render in Helvetica, 12pt:
/Helvetica findfont 12 scalefont setfont
% somewhere in the lower left-hand corner:
50 dup moveto
% render text
(Goodbye, World!) show
% wrap up page display:
showpage

[edit] PowerBASIC

Works with: PB/Win

FUNCTION PBMAIN() AS LONG
    MSGBOX "Goodbye, World!"
END FUNCTION

[edit] PowerShell

Library: WPK

Works with: PowerShell version 2

New-Label "Goodbye, World!" -FontSize 24 -Show

Library: Windows Forms

$form = New-Object System.Windows.Forms.Form
$label = New-Object System.Windows.Forms.Label
 
$label.Text = "Goodbye, World!"
$form.AutoSize = $true
$form.AutoSizeMode = [System.Windows.Forms.AutoSizeMode]::GrowAndShrink
$form.Controls.Add($label)
 
$Form.ShowDialog() | Out-Null

Alternatively, simply as a message box:

Library: Windows Forms

[System.Windows.Forms.MessageBox]::Show("Goodbye, World!")

[edit] Prolog

Works with SWI-Prolog and XPCE.

A simple message box :

send(@display, inform, 'Goodbye, World !').

A more sophisticated window :

goodbye :-
    new(D, window('Goodbye')),
    send(D, size, size(250, 100)),
    new(S, string("Goodbye, World !")),
    new(T, text(S)),
    get(@display, label_font, F),
    get(F, width(S), M),
    XT is (250 - M)/2,
    get(F, height, H),
    YT = (100-H)/2,
    send(D, display, T, point(XT, YT)),
    send(D, open).

[edit] PureBasic

MessageRequester("Hello","Goodbye, World!")

Using the Windows API:

MessageBox_(#Null,"Goodbye, World!","Hello")

[edit] Python

Works with: Python version 2.x

Library: Tkinter

import tkMessageBox
 
result = tkMessageBox.showinfo("Some Window Label", "Goodbye, World!")

Note: The result is a string of the button that was pressed.

Works with: Python version 3.x

Library: Tkinter

from tkinter import messagebox
 
result = messagebox.showinfo("Some Window Label", "Goodbye, World!")

Library: PyQt

import PyQt4.QtGui
app = PyQt4.QtGui.QApplication([])
pb = PyQt4.QtGui.QPushButton('Hello World')
pb.connect(pb,PyQt4.QtCore.SIGNAL("clicked()"),pb.close)
pb.show()
exit(app.exec_())

Library: PyGTK

import pygtk
pygtk.require('2.0')
import gtk
 
window = gtk.Window()
window.set_title('Goodbye, World')
window.connect('delete-event', gtk.main_quit)
window.show_all()
gtk.main()

Library: WxPython

import wx
 
app = wx.App(False)
frame = wx.Frame(None, wx.ID_ANY, "Hello, World")
frame.Show(True)
app.MainLoop()

[edit] RapidQ

MessageBox("Goodbye, World!", "RapidQ example", 0)

[edit] R

Library: GTK

Rather minimalist, but working...

library(RGtk2)   # bindings to Gtk
w <- gtkWindowNew()
l <- gtkLabelNew("Goodbye, World!")
w$add(l)

[edit] Racket

 #lang racket/gui
(require racket/gui/base)
 
; Make a frame by instantiating the frame% class
(define frame (new frame% [label "Goodbye, World!"]))
 
; Make a static text message in the frame
(define msg (new message% [parent frame]
                          [label "No events so far..."]))
 
; Make a button in the frame
(new button% [parent frame]
             [label "Click Me"]
             ; Callback procedure for a button click:
             (callback (lambda (button event)
                         (send msg set-label "Button click"))))
 
; Show the frame by calling its show method
(send frame show #t)

[edit] Rascal

 
import vis::Figure;
import vis::Render;
 
public void GoodbyeWorld() = 
	render(box(text("Goodbye World")));

Output:

[edit] REBOL

alert "Goodbye, World!"

[edit] REXX

[edit] version 1

This REXX example only works with:

PC/REXX
Personal REXX

/*REXX (PC/REXX) to display a message in a window (which is bordered).  */
 
/*REXX (PC/REXX) to display a message in a window (which is bordered).  */
if fcnpkg('rxwindow')¬==1 then do
                               say 'RXWINDOW function package not loaded.'
                               exit 13
                               end
 
if pcvideo()==3  then normal= 7
                 else normal=13
 
window#=w_open(1, 1, 3, 80, normal)
call w_border window#
call w_put window#, 2, 2, center("Goodbye, World!", 80-2)
 
                                       /*stick a fork in it, we're done.*/

output

╔══════════════════════════════════════════════════════════════════════════════╗
║                               Goodbye, World!                                ║
╚══════════════════════════════════════════════════════════════════════════════╝

[edit] version 2

This REXX example only works with:

PC/REXX
Personal REXX

and it creates two windows, the first (main) window contains the Goodbye, World! text,
the other "help" window contains a message about how to close the windows.

/*REXX pgm shows a "hello world" window (& another to show how to close)*/
parse upper version !ver .; !pcrexx='REXX/PERSONAL'==!ver |'REXX/PC'==!ver
if \!pcrexx then call ser "This isn't PC/REXX"        /* is ¬ PC/REXX ? */
rxWin=fcnpkg('rxwindow')                              /*function around?*/
if rxWin\==1 then do 1;     'RXWINDOW /q'
                  if fcnpkg('rxwindow')==1 then leave /*function is OK. */
                  say 'error loading RXWINDOW !';     exit 13
                  end
top=1;       normal=31;    border=30;   curpos=cursor()
width=40;    height=11;    line.=;      line.1='Goodbye, World!'
w=w_open(2,3,height+2,width,normal);    call w_border w,,,,,border
helpLine="press the  esc  key to quit"
helpw=w_open(2,50,3,length(helpLine)+4,normal)
call w_border helpw,,,,,border;  call w_put helpw,2,3,helpLine
call w_hide w, 'n'
                             do k=0  to height-1
                             _=top+k;  call w_put w,k+2,3,line._,width-4
                             end   /*k*/
call w_unhide w; esc='1b'x
                             do forever;  if inkey()=esc then leave;  end
call w_close w
call w_close helpw
if rxWin\==1  then 'RXUNLOAD rxwindow'
parse var curpos row col
call      cursor row, col
                                       /*stick a fork in it, we're done.*/

[edit] Ruby

Library: GTK

require 'gtk2'
 
window = Gtk::Window.new
window.title = 'Goodbye, World'
window.signal_connect(:delete-event) { Gtk.main_quit }
window.show_all
 
Gtk.main

Library: Ruby/Tk

require 'tk'
root = TkRoot.new("title" => "User Output")
TkLabel.new(root, "text"=>"CHUNKY BACON!").pack("side"=>'top')
Tk.mainloop

Library: Shoes

#_Note: this code MUST be executed through the Shoes GUI!!
 
Shoes.app do
	para "CHUNKY BACON!", :size => 72
end

[edit] Run BASIC

' do it with javascript
html "<script>alert('Goodbye, World!');</script>"

[edit] Scala

Library: Swing

Simple solution as script:

swing.Dialog.showMessage(message = "Goodbye, World!")

Longer example, as an application (translation of Java):

import swing._
 
object GoodbyeWorld extends SimpleSwingApplication {
 
  Dialog.showMessage(message = "Goodbye, World!")
 
  def top = new MainFrame {
    title = "Goodbye, World!"                     
    contents = new FlowPanel {
      contents += new Button  ("Goodbye, World!") 
      contents += new TextArea("Goodbye, World!")
    }
  }
}

[edit] Scheme

Library: Scheme/PsTk

 
#!r6rs
 
;; PS-TK example: display frame + label
 
(import (rnrs) 
        (lib pstk main) ; change this to refer to your PS/Tk installation
        )
 
(define tk (tk-start))
(tk/wm 'title tk "PS-Tk Example: Label")
 
(let ((label (tk 'create-widget 'label 'text: "Goodbye, world")))
  (tk/place label 'height: 20 'width: 50 'x: 10 'y: 20))
 
(tk-event-loop tk)

[edit] Scratch

[edit] Seed7

Seed7 does not work with an event handling function like gtk_main(). The progam stays in control and does not depend on callbacks. The graphic library manages redraw, keyboard and mouse events. The contents of a window are automatically restored when it is uncovered. It is possible to copy areas from a window even when the area is currently covered or off screen.

$ include "seed7_05.s7i";
  include "draw.s7i";
  include "keybd.s7i";
  include "bitmapfont.s7i";
  include "stdfont24.s7i";
  include "pixmap_file.s7i";
 
const proc: main is func
  local
    var text: screen is STD_NULL;
  begin
    screen(400, 100);
    clear(curr_win, white);
    KEYBOARD := GRAPH_KEYBOARD;
    screen := openPixmapFontFile(curr_win);
    color(screen, black, white);
    setFont(screen, stdFont24);
    setPosXY(screen, 68,  60);
    write(screen, "Goodbye, World");
    ignore(getc(KEYBOARD));
  end func;

[edit] Smalltalk

Works with: GNU Smalltalk

MessageBox show: 'Goodbye, world.'

Works with: Smalltalk/X

Works with: VisualWorks Smalltalk

Dialog information: 'Goodbye, world.'

[edit] Supernova

I want window and the window title is "Goodbye, World".

[edit] Tcl

Library: Tk

Just output as a label in a window:

pack [label .l -text "Goodbye, World"]

Output as text on a button that exits the current application:

pack [button .b -text "Goodbye, World" -command exit]

Or as a message box:

tk_messageBox -message "Goodbye, World"

[edit] TI-89 BASIC

Dialog
  Text "Goodbye, World!"
EndDlog

[edit] Vedit macro language

Displaying the message on status line. The message remains visible until the next keystroke, but macro execution continues.

Statline_Message("Goodbye, World!")

Displaying a dialog box with the message and default OK button:

Dialog_Input_1(1,"`Vedit example`,`Goodbye, World!`")

[edit] UNIX Shell

[edit] In a virtual terminal

Using whiptail or dialog

 
whiptail --title 'Farewell' --msgbox 'Goodbye, World!' 7 20

 
dialog --title 'Farewell' --msgbox 'Goodbye, World!' 7 20

[edit] In a graphical environment

Using the simple dialog command xmessage, which uses the X11 Athena Widget library

 
xmessage 'Goodbye, World!'

Using the zenity modal dialogue command (wraps GTK library) available with many distributions of Linux

 
zenity --info --text='Goodbye, World!'

Using yad (a fork of zenity with many more advanced options)

 
yad --title='Farewell' --text='Goodbye, World!'

[edit] Visual Basic

Sub Main()
    MsgBox "Goodbye, World!"
End Sub

[edit] Visual Basic .NET

Works with: Visual Basic version 2005

Module GoodbyeWorld
    Sub Main()
        Messagebox.Show("Goodbye, World!")
    End Sub
End Module

[edit] X86 Assembly

Works with: nasm

This example used the Windows MessageBox function to do the work for us. Windows uses the stdcall calling convention where the caller pushes function parameters onto the stack and the stack has been fixed up when the callee returns.

;;; hellowin.asm
;;;
;;; nasm -fwin32 hellowin.asm
;;; link -subsystem:console -out:hellowin.exe -nodefaultlib -entry:main \
;;;    hellowin.obj user32.lib kernel32.lib
 
        global _main
        extern _MessageBoxA@16
        extern _ExitProcess@4
 
        MessageBox equ _MessageBoxA@16
        ExitProcess equ _ExitProcess@4
 
        section .text
_main:
        push 0                  ; MB_OK
        push title              ;
        push message            ;
        push 0                  ;
        call MessageBox         ; eax = MessageBox(0,message,title,MB_OK);
        push eax                ; 
        call ExitProcess        ; ExitProcess(eax);
message:
        db 'Goodbye, World',0
title:
        db 'RosettaCode sample',0

Works with: FASM on Windows

 
;use win32ax for 32 bit
;use win64ax for 64 bit
include 'win64ax.inc'
 
.code
   start:
      invoke MessageBox,HWND_DESKTOP,"Goodbye,World!","Goodbye",MB_OK
      invoke ExitProcess,0
.end start

[edit] Web 68

@1Introduction.
Define the structure of the program.
 
@aPROGRAM goodbye world CONTEXT VOID USE standard
BEGIN
@<Included declarations@>
@<Logic at the top level@>
END
FINISH
 
@ Include the graphical header file.
 
@iforms.w@>
 
@ Program code.
 
@<Logic...@>=
open(LOC FILE,"",arg channel);
fl initialize(argc,argv,NIL,0);
fl show messages("Goodbye World!");
fl finish
 
@ Declare the necessary macros.
 
@<Include...@>=
macro fl initialize;
macro fl show messages;
macro fl finish;
 
@ The end.

Hello world/Graphical

Contents

[edit] ActionScript

[edit] Ada

[edit] AppleScript

[edit] Applesoft BASIC

[edit] ATS

[edit] AutoHotkey

[edit] AutoIt

[edit] BASIC

[edit] BASIC256

[edit] BBC BASIC

[edit] C

[edit] C#

[edit] C++

[edit] C++/CLI

[edit] Clean

[edit] Clojure

[edit] COBOL

[edit] Cobra

[edit] CoffeeScript

[edit] Common Lisp

[edit] Creative Basic

[edit] D

[edit] Delphi

[edit] Dylan

[edit] E

[edit] eC

[edit] Euphoria

[edit] Message box

[edit] EGL

[edit] F#

[edit] Factor

[edit] Fantom

[edit] Forth

[edit] Frink

[edit] Gambas

[edit] Go

[edit] Groovy

[edit] GUISS

[edit] Haskell

[edit] HicEst

[edit] Icon and Unicon

[edit] Icon

[edit] Unicon

[edit] Integer BASIC

[edit] Ioke

[edit] IWBASIC

[edit] J

[edit] Java

[edit] JavaScript

[edit] Just Basic

[edit] KonsolScript

[edit] LabVIEW

[edit] Liberty BASIC

[edit] Logo

[edit] Lua

[edit] Maple

[edit] Mathematica

[edit] MATLAB

[edit] MAXScript

[edit] mIRC Scripting Language

[edit] Modula-3

[edit] Nemerle

[edit] NetRexx

[edit] newLISP

[edit] Objective-C

[edit] Objeck

[edit] OCaml

[edit] OxygenBasic

[edit] Oxygene

[edit] Glade

[edit] .NET

[edit] Oz

[edit] OpenEdge/Progress

[edit] Panoramic

[edit] Pascal

[edit] Perl

[edit] Perl 6

[edit] PHP