Hello world/Graphical

From Rosetta Code
Task
Hello world/Graphical
You are encouraged to solve this task according to the task description, using any language you may know.


Task

Display the string       Goodbye, World!       on a GUI object   (alert box, plain window, text area, etc.).


Related task



Contents

ActionScript[edit]

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

Ada[edit]

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;

ALGOL 68[edit]

The code below is a gentle re-write (including a bug fix) of that in the Algol 68 Genie documentation.

 
BEGIN
FILE window;
open (window, "Hello!", stand draw channel);
draw device (window, "X", "600x400");
draw erase (window);
draw move (window, 0.25, 0.5);
draw colour (window, 1, 0, 0);
draw text (window, "c", "c", "Goodbye, world!");
draw show (window);
close (window)
END
 

App Inventor[edit]

No Blocks solution[edit]

This solution requires no code blocks as the text is entered directly into the Title properties TextBox of the Designer.
VIEW THE DESIGNER

Three blocks solution[edit]

This solution uses three blocks to assign the text to the Title bar:
Screen1.Initialize and
set Screen1.Title to "Goodbye World!"
VIEW THE BLOCKS AND ANDROID APP SCREEN

AppleScript[edit]

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

Applesoft BASIC[edit]

  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

Arendelle[edit]

// title

   "Hello, World!"

// first spacings

   [ 5 , rd ]

// body

   /* H */ [7,pd][4,u][3,pr][3,d][7,pu]drr
   /* E */ [6,pd][4,pr]l[3,u][2,lp][3,u][3,pr]r
   /* L */ [7,pd]u[3,rp][6,u]rr
   /* L */ [7,pd]u[3,rp][6,u]rr
   /* O */ [7,pd]u[2,rp]r[6,pu][3,pl][5,r]
   /* , */ [5,d]prpd[3,pld][9,u][5,r]
   /*   */ rrr
   /* W */ [4,pd][2,prd][2,pru][5,pu][5,d][2,prd][2,pru][5,pu]rrd
   /* O */ [7,pd]u[2,rp]r[6,pu][3,pl][5,r]
   /* R */ [7,pd][7,u][3,rp][3,pd][3,pl]rrdpr[2,dp][6,u]rr
   /* L */ [7,pd]u[3,rp][6,u]rr
   /* D */ [6,pd][3,pr][5,up]u[2,lp]p[4,r]
   /* ! */ r[5,pd]dp[6,u]rr

// done

ATS[edit]

//
#include
"share/atspre_define.hats"
#include
"share/atspre_staload.hats"
//
(* ****** ****** *)
 
staload UN = $UNSAFE
 
(* ****** ****** *)
 
staload "{$GLIB}/SATS/glib.sats"
 
(* ****** ****** *)
 
staload "{$GTK}/SATS/gdk.sats"
staload "{$GTK}/SATS/gtk.sats"
staload "{$GLIB}/SATS/glib-object.sats"
 
(* ****** ****** *)
 
%{^
typedef char **charpp ;
%} ;
abstype charpp = $extype"charpp"
 
(* ****** ****** *)
 
fun hello
(
widget: !GtkWidget1, _: gpointer
) : void = print ("Goodbye, world!\n")
 
fun on_delete_event
(
widget: !GtkWidget1
, event: &GdkEvent, udata: gpointer
) : gboolean = let
val () = print ("delete event occurred\n")
in
GTRUE // handling of delete-event is finished
end // end of [on_delete_event]
 
fun on_destroy
(widget: !GtkWidget1, _: gpointer): void = gtk_main_quit ()
// end of [on_destroy]
 
(* ****** ****** *)
 
macdef nullp = the_null_ptr
 
(* ****** ****** *)
 
implement
main0 (argc, argv) =
{
//
var argc: int = argc
var argv: charpp = $UN.castvwtp1{charpp}(argv)
//
val () = $extfcall (void, "gtk_init", [email protected](argc), [email protected](argv))
//
val window =
gtk_window_new (GTK_WINDOW_TOPLEVEL)
val () = assertloc (ptrcast(window) > 0)
//
val _(*id*) =
g_signal_connect (
window, (gsignal)"destroy", (G_CALLBACK)on_destroy, (gpointer)nullp
) (* end of [val] *)
val _(*id*) =
g_signal_connect (
window, (gsignal)"delete_event", (G_CALLBACK)on_delete_event, (gpointer)nullp
) (* end of [val] *)
//
val () = gtk_container_set_border_width (window, (guint)10)
val button = gtk_button_new_with_label (gstring("Goodbye, world!"))
val () = assertloc (ptrcast(button) > 0)
//
val () = gtk_widget_show (button)
val () = gtk_container_add (window, button)
val () = gtk_widget_show (window)
//
val _(*id*) =
g_signal_connect
(
button, (gsignal)"clicked", (G_CALLBACK)hello, (gpointer)nullp
)
val _(*id*) =
g_signal_connect_swapped
(
button, (gsignal)"clicked", (G_CALLBACK)gtk_widget_destroy, window
)
//
val () = g_object_unref (button)
val () = g_object_unref (window) // ref-count becomes 1!
//
val ((*void*)) = gtk_main ()
//
} (* end of [main0] *)

AutoHotkey[edit]

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!

AutoIt[edit]

#include <GUIConstantsEx.au3>
 
$hGUI = GUICreate("Hello World") ; Create the main GUI
GUICtrlCreateLabel("Goodbye, World!", -1, -1) ; Create a label dispalying "Goodbye, World!"
 
GUISetState() ; Make the GUI visible
 
While 1 ; Infinite GUI loop
$nMsg = GUIGetMsg() ; Get any messages from the GUI
Switch $nMsg ; Switch for a certain event
Case $GUI_EVENT_CLOSE ; When an user closes the windows
Exit ; Exit
 
EndSwitch
WEnd
 
MsgBox(0, "Goodbye", "Goodbye, World!")
ToolTip("Goodbye, World!")

AWK[edit]

Awk has no GUI, but can execute system-commands.

E.g. the Windows-commandline provides a command for a messagebox,
see below at Batch_File and UNIX_Shell.

# Usage:  awk -f hi_win.awk
BEGIN { system("msg * Goodbye, Msgbox !") }
 

Axe[edit]

This example is almost identical to the TI-83 BASIC version.

ClrHome
Text(0,0,"Goodbye, world!")
Pause 5000

BaCon[edit]

Uses HUG (High level Universal GUI) shipped in hug.bac

REM GUI greeting
 
INCLUDE "hug.bac"
 
mainwindow = WINDOW("BaCon greeting", 225, 40)
 
greeting = ENTRY("Goodbye, World!", 115, 30)
ATTACH(mainwindow, greeting, 5, 5)
 
REM gtk event LOOP...
DISPLAY
 

BASIC[edit]

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

BASIC256[edit]

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

Batch File[edit]

From Window 7 and later, pure Batch File does not completely provide GUI. However, MSHTA.EXE provides command-line JavaScript/VBScript access.

@echo off

::Output to message box [Does not work in Window 7 and later]

msg * "Goodbye, World!" 2>nul

::Using MSHTA.EXE Hack::

@mshta javascript:alert("Goodbye, World!");code(close());
@mshta vbscript:Execute("msgbox(""Goodbye, World!""):code close")
pause

BBC BASIC[edit]

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

BML[edit]

msgbox Goodbye, World!

C[edit]

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!"));
}

C#[edit]

Library: Windows Forms
using System;
using System.Windows.Forms;
 
class Program {
static void Main(string[] args) {
Application.EnableVisualStyles(); //Optional.
MessageBox.Show("Goodbye, 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();
}
}

C++[edit]

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

C++/CLI[edit]

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

Clean[edit]

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

Clojure[edit]

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

COBOL[edit]

GUI[edit]

The following are in the Managed COBOL dialect.

Works with: Visual COBOL
Library: Windows Forms
Translation of: C#
       CLASS-ID ProgramClass.
METHOD-ID Main STATIC.
PROCEDURE DIVISION.
INVOKE TYPE Application::EnableVisualStyles() *> Optional
INVOKE TYPE MessageBox::Show("Goodbye, World!")
END METHOD.
END CLASS.

gui.xaml.cbl:

       CLASS-ID GoodbyeWorldWPF.Window IS PARTIAL
INHERITS TYPE System.Windows.Window.
METHOD-ID NEW.
PROCEDURE DIVISION.
INVOKE self::InitializeComponent()
END METHOD.
END CLASS.

gui.xaml:

<Window x:Class="COBOL_WPF.Window1"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="Hello world/Graphical">
<TextBox>Goodbye, World!</TextBox>
</Window>

GTK[edit]

Works with: GnuCOBOL version 2.0
Library: cobweb-gtk
      *>
*> cobweb-gui-hello, using gtk-label
*> Tectonics:
*> cobc -w -xj cobweb-gui-hello.cob cobweb-gtk.cob \
*> `pkg-config --libs gtk+-3.0`
*>
identification division.
program-id. cobweb-gui-hello.
 
environment division.
configuration section.
repository.
function new-window
function new-box
function new-label
function gtk-go
function all intrinsic.
 
data division.
working-storage section.
 
01 TOPLEVEL usage binary-long value 0.
01 HORIZONTAL usage binary-long value 0.
01 VERTICAL usage binary-long value 1.
 
01 width-hint usage binary-long value 160.
01 height-hint usage binary-long value 16.
 
01 spacing usage binary-long value 8.
01 homogeneous usage binary-long value 0.
 
01 extraneous usage binary-long.
 
01 gtk-window-data.
05 gtk-window usage pointer.
01 gtk-container-data.
05 gtk-container usage pointer.
 
01 gtk-box-data.
05 gtk-box usage pointer.
01 gtk-label-data.
05 gtk-label usage pointer.
 
procedure division.
cobweb-hello-main.
 
*> Main window and top level container
move new-window("Hello", TOPLEVEL, width-hint, height-hint)
to gtk-window-data
move new-box(gtk-window, VERTICAL, spacing, homogeneous)
to gtk-container-data
 
*> Box, across, with simple label
move new-box(gtk-container, HORIZONTAL, spacing, homogeneous)
to gtk-box-data
move new-label(gtk-box, "Goodbye, World!") to gtk-label-data
 
*> GTK+ event loop now takes over
move gtk-go(gtk-window) to extraneous
 
goback.
end program cobweb-gui-hello.

TUI[edit]

Works with: OpenCOBOL version 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.

Cobra[edit]

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
 

CoffeeScript[edit]

alert "Goodbye, World!"

Common Lisp[edit]

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

This can also be done using the CLIM 2.0 specification. The following code runs on both SBCL and the LispWorks IDE:

Library: CLIM
 
((in-package :clim-user)
 
(defclass hello-world-pane
(clim-stream-pane) ())
 
(define-application-frame hello-world ()
((greeting :initform "Goodbye World"
:accessor greeting))
(:pane (make-pane 'hello-world-pane)))
 
;;; Behaviour defined by the Handle Repaint Protocol
(defmethod handle-repaint ((pane hello-world-pane) region)
(let ((w (bounding-rectangle-width pane))
(h (bounding-rectangle-height pane)))
;; Blank the pane out
(draw-rectangle* pane 0 0 w h
:filled t
:ink (pane-background pane))
;; Draw greeting in center of pane
(draw-text* pane
(greeting *application-frame*)
(floor w 2) (floor h 2)
:align-x :center
:align-y :center)))
 
(run-frame-top-level
(make-application-frame 'hello-world
:width 200 :height 200))

Creative Basic[edit]

 
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 @[email protected] THEN Close=1
 
RETURN
 

D[edit]

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

Delphi[edit]

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

Dylan[edit]

(This works entered into the interactive shell):

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

E[edit]

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

eC[edit]

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

EchoLisp[edit]

 
(alert "Good bye, world!")
 

Elena[edit]

ELENA 3.2 :

import forms.
 
class Window :: SDIDialog
{
object goodByeWorldLabel.
object closeButton.
 
constructor new
<= new;
[
goodByeWorldLabel := Label new.
closeButton  := Button new.
 
theControls
append:goodByeWorldLabel;
append:closeButton.
 
$self
set x:250 y:200;
set width:200 height:110.
 
goodByeWorldLabel
set x:40 y:10;
set width:150 height:30;
set caption:"Goodbye, World!".
 
closeButton
set x:20 y:40;
set width:150 height:30;
set caption:"Close";
set onClick(:args)[ 'program stop ]
]
}

Euphoria[edit]

Message box[edit]

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

EGL[edit]

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
 


F#[edit]

Just display the text in a message box.

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

Factor[edit]

To be pasted in the listener :

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

Fantom[edit]

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

Forth[edit]

Works with: SwiftForth
HWND z" Goodbye, World!" z" (title)" MB_OK MessageBox

Alternative:

Works with: Win32Forth version 6.15.03
 s" Goodbye, World!" MsgBox

Fortran[edit]

MS Windows[edit]

Here are solutions for Microsoft Windows, using the MessageBox API function. Both programs use modules provided by the compiler vendor.

Works with: Absoft Pro Fortran
program hello
use windows
integer :: res
res = MessageBox(0, LOC("Hello, World"), LOC("Window Title"), MB_OK)
end program

Compile with af90 hello.f90 user32.lib.

Works with: Intel Fortran
program hello
use user32
integer :: res
res = MessageBox(0, "Hello, World", "Window Title", MB_OK)
end program

Compile with ifort hello.f90.

Linux[edit]

Using gtk-fortran library

Works with: GNU Fortran
 
module handlers_m
use iso_c_binding
use gtk
implicit none
 
contains
 
subroutine destroy (widget, gdata) bind(c)
type(c_ptr), value :: widget, gdata
call gtk_main_quit ()
end subroutine destroy
 
end module handlers_m
 
program test
use iso_c_binding
use gtk
use handlers_m
implicit none
 
type(c_ptr) :: window
type(c_ptr) :: box
type(c_ptr) :: button
 
call gtk_init ()
window = gtk_window_new (GTK_WINDOW_TOPLEVEL)
call gtk_window_set_default_size(window, 500, 20)
call gtk_window_set_title(window, "gtk-fortran"//c_null_char)
call g_signal_connect (window, "destroy"//c_null_char, c_funloc(destroy))
box = gtk_hbox_new (TRUE, 10_c_int);
call gtk_container_add (window, box)
button = gtk_button_new_with_label ("Goodbye, World!"//c_null_char)
call gtk_box_pack_start (box, button, FALSE, FALSE, 0_c_int)
call g_signal_connect (button, "clicked"//c_null_char, c_funloc(destroy))
call gtk_widget_show (button)
call gtk_widget_show (box)
call gtk_widget_show (window)
call gtk_main ()
 
end program test
 

Compile with gfortran gtk2_mini.f90 -o gtk2_mini.x `pkg-config --cflags --libs gtk-2-fortran`

FreeBASIC[edit]

'FreeBASIC Hello-fb0.bas May 2015
 
Screen 0 'open text window
Print "Hello world"
 
Print "Enter any key to go the graphics screen"
sleep
 
screen 18 'Screen 18 Resolution 640x480 with at least 256 colors
locate 10,10
Print "Hello world!"
 
locate 20,10
Print "Enter any key to exit"
sleep
End

Frege[edit]

package HelloWorldGraphical where
 
import Java.Swing
 
main _ = do
frame <- JFrame.new "Goodbye, world!"
frame.setDefaultCloseOperation(JFrame.dispose_on_close)
label <- JLabel.new "Goodbye, world!"
cp <- frame.getContentPane
cp.add label
frame.pack
frame.setVisible true

Frink[edit]

This brings up an infinitely-rescalable graphic window containing "Goodbye, World" drawn graphically.

All Frink graphics can be written to arbitrary coordinates; Frink will automatically scale and center any drawn graphics to be visible in the window (greatly simplifying programming,) so the exact coordinates used below are rather arbitrary. (This means that if you wrote "Hello World" instead of "Goodbye, World", you could just change that string and everything would still center perfectly.)

The graphics are infinitely-scalable and can be rendered at full quality to any resolution. This program "shows off" by rotating the text by 10 degrees, and also rendering it to a printer (which can include tiling across multiple pages) and rendering to a graphics file. (Frink can automatically render the same graphics object to many image formats, including PNG, JPG, SVG, HTML5 canvas, animated GIF, bitmapped image in memory, and more.)

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

FunL[edit]

native javax.swing.{SwingUtilities, JPanel, JLabel, JFrame}
native java.awt.Font
 
def createAndShowGUI( msg ) =
f = JFrame()
f.setTitle( msg )
f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE )
p = JPanel()
l = JLabel( msg )
l.setFont( Font.decode(Font.SERIF + ' 150') )
p.add( l )
f.add( p )
f.pack()
f.setResizable( false )
f.setVisible( true )
 
SwingUtilities.invokeLater( createAndShowGUI.runnable('Goodbye, World!') )

Gambas[edit]

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

GML[edit]

draw_text(0,0,"Goodbye World!");

Go[edit]

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

Groovy[edit]

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

GUISS[edit]

Here we display the message on the system notepad:

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

Harbour[edit]

PROCEDURE Main()
RETURN wapi_MessageBox(,"Goodbye, World!","")
 

Haskell[edit]

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

HicEst[edit]

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

HPPPL[edit]

With an alert box:

MSGBOX("Goodbye, World!");

By drawing directly to the screen:

RECT();
TEXTOUT_P("Goodbye, World!", GROBW_P(G0)/4, GROBH_P(G0)/4, 7);
WAIT(-1);

I[edit]

gui {
Goodbye, World!
}

HolyC[edit]

PopUpOk("Goodbye, World!");

Icon and Unicon[edit]

Icon[edit]

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

graphics is required

Unicon[edit]

 
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
 

Integer BASIC[edit]

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
 

Ioke[edit]

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
)

IWBASIC[edit]

 
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 @[email protected] THEN Close=1
 
RETURN
ENDSUB
 

J[edit]

wdinfo 'Goodbye, World!'

Java[edit]

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

Using Java 8 lambdas syntax:

import javax.swing.*;
import java.awt.*;
 
public class HelloWorld {
public static void main(String[] args) {
 
SwingUtilities.invokeLater(() -> {
JOptionPane.showMessageDialog(null, "Goodbye, world!");
JFrame frame = new JFrame("Goodbye, world!");
JTextArea text = new JTextArea("Goodbye, world!");
JButton button = new JButton("Goodbye, world!");
 
frame.setLayout(new FlowLayout());
frame.add(button);
frame.add(text);
frame.pack();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
});
}
}

JavaScript[edit]

 alert("Goodbye, World!");

jq[edit]

Works with: jq version 1.4

In the following, which generates SVG in a way that can be readily viewed using a web browser, the "Goodbye, World!" text is shaded using a linear gradient.

The approach used here to generate SVG is based on these principles:

  • a JSON object is used to specify CSS styles
    • this makes it easy to combine default specifications with partial specifications, because in jq, for JSON objects, "+" is defined so that (default + partial) is the combination which gives precedence to the right-hand-side operand;
  • for other defaults, the jq "//" operator can be used; thus all SVG parameters can be easily given defaults.

Part 1: Generic SVG-related functions

# Convert a JSON object to a string suitable for use as a CSS style value
# e.g: "font-size: 40px; text-align: center;" (without the quotation marks)
def to_s:
reduce to_entries[] as $pair (""; . + "\($pair.key): \($pair.value); ");
 
# Defaults: 100%, 100%
def svg(width; height):
"<svg width='\(width // "100%")' height='\(height // "100%")'
xmlns='http://www.w3.org/2000/svg'>";
 
# Defaults:
# id: "linearGradient"
# color1: rgb(0,0,0)
# color2: rgb(255,255,255)
def linearGradient(id; color1; color2):
"<defs>
<linearGradient id='\(id//"linearGradient")' x1='0%' y1='0%' x2='100%' y2='0%'>
<stop offset='0%' style='stop-color:\(color1//"rgb(0,0,0)");stop-opacity:1' />
<stop offset='100%' style='stop-color:\(color2//"rgb(255,255,255)");stop-opacity:1' />
</linearGradient>
</defs>";
 
# input: the text string
# "style" should be a JSON object (see for example the default ($dstyle));
# the style actually used is (default + style), i.e. whatever is specified in "style" wins.
# Defaults:
# x: 0
# y: 0
def text(x; y; style):
. as $in
| {"font-size": "40px", "text-align": "center", "text-anchor": "left", "fill": "black"} as $dstyle
| (($dstyle + style) | to_s) as $style
| "<text x='\(x//0)' y='\(y//0)' style='\($style)'>
\(.)",
"</text>";

Part 2: "Goodbye, World!"

def task:
svg(null;null), # use the defaults
linearGradient("gradient"; "rgb(255,255,0)"; "rgb(255,0,0)"), # define "gradient"
("Goodbye, World!" | text(10; 50; {"fill": "url(#gradient)"})), # notice how the default for "fill" is overridden
"</svg>";
 
task
Output:
jq -n -r -f Hello_word_Graphical.jq > Hello_word_Graphical.svg

Just Basic[edit]

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

Julia[edit]

Library: Tk
using Tk
 
window = Toplevel("Hello World", 200, 100, false)
pack_stop_propagate(window)
 
fr = Frame(window)
pack(fr, expand=true, fill="both")
 
txt = Label(fr, "Hello World")
pack(txt, expand=true)
 
set_visible(window, true)
 
# sleep(7)

KonsolScript[edit]

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

Kotlin[edit]

Translation of: Java
Library: Swing
import java.awt.*
import javax.swing.*
 
fun main(args: Array<String>) {
JOptionPane.showMessageDialog(null, "Goodbye, World!") // in alert box
with(JFrame("Goodbye, World!")) { // on title bar
layout = FlowLayout()
add(JButton("Goodbye, World!")) // on button
add(JTextArea("Goodbye, World!")) // in editable area
pack()
defaultCloseOperation = JFrame.EXIT_ON_CLOSE
isVisible = true
}
}

LabVIEW[edit]

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.
LabVIEW Hello world Graphical.png

Lasso[edit]

On OS X machines:

sys_process('/usr/bin/osascript', (: '-e', 'display dialog "Goodbye, World!"'))->wait

Liberty BASIC[edit]

NOTICE "Goodbye, world!"

Lingo[edit]

Display in alert box:

_player.alert("Goodbye, World!")

Display in main window ("stage"):

-- create a field
m = new(#field)
m.rect = rect(0,0,320,240)
m.alignment = "center"
m.fontsize = 24
m.fontStyle = "bold"
m.text = "Goodbye, World!"
 
-- create sprite, assign field
_movie.puppetSprite(1, TRUE)
sprite(1).member = m
sprite(1).loc = point(0,105)
 
-- force immediate update
_movie.updateStage()

LiveCode[edit]

answer "Goodbye, World!"

A dialog box can be modified as appropriate for the context by setting a "iconType", button text and title

answer warning "Goodbye, World!" with "Goodbye, World!" titled "Goodbye, World!"

Lobster[edit]

gl_window("graphical hello world", 800, 600)
gl_setfontname("data/fonts/Droid_Sans/DroidSans.ttf")
gl_setfontsize(30)
 
while gl_frame():
gl_clear([ 0.0, 0.0, 0.0, 1.0 ])
gl_text("Goodbye, World!")

[edit]

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

Lua[edit]

Library: IUPLua
[edit]

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

Library: LÖVE
[edit]

To actually run this LÖVE-program, the following code needs to be in a file main.lua, in its own folder.
This folder usually also contains other resources for a game, such as pictures, sound, music, other source-files, etc.

To run the program, on windows, drag that folder onto either love.exe or a shortcut to love.exe.

 
function love.draw()
love.graphics.print("Goodbye, World!", 400, 300)
end
 

Maple[edit]

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

Mathematica / Wolfram Language[edit]

CreateDialog["Hello world"]

MATLAB[edit]

msgbox('Goodbye, World!')

Add text to a graphical plot.

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

MAXScript[edit]

messageBox "Goodbye world"

mIRC Scripting Language[edit]

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
}

Modula-3[edit]

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

Nemerle[edit]

Compile with:
ncc -reference:System.Windows.Forms goodbye.n
using System;
using System.Windows.Forms;
 
MessageBox.Show("Goodbye, World!")

NetRexx[edit]

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
 

newLISP[edit]

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.
 

Nim[edit]

Library: GTK2
[edit]

import dialogs, gtk2
gtk2.nim_init()
 
info(nil, "Hello World")

Library: IUP
[edit]

import iup
 
discard iup.open(nil, nil)
message("Hello", "Hello World")
close()

Objective-C[edit]

To show a modal alert (Mac):

NSAlert *alert = [[NSAlert alloc] init];
[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];
[alert show];

Objeck[edit]

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


OCaml[edit]

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

OxygenBasic[edit]

Windows MessageBox:

print "Hello World!"


Oxygene[edit]

Glade[edit]

HelloWorld


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.
 

.NET[edit]

HelloWorld


 
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.
 

Oz[edit]

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

OpenEdge/Progress[edit]

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

Panoramic[edit]

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

Pascal[edit]

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.

Perl[edit]

Works with: Perl version 5.8.8

Library: Perl/Tk
[edit]

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: Perl/Gtk2
[edit]

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: Perl/Qt
[edit]

use strict;
use warnings;
use QtGui4;
 
my $app = Qt::Application(\@ARGV);
my $label = Qt::Label('Goodbye, World');
$label->show;
exit $app->exec;

Library: XUL::GuiGui
[edit]

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

Perl 6[edit]

Library: GTK
use GTK::Simple;
 
my GTK::Simple::App $app .= new;
$app.border_width = 20;
$app.set_content( GTK::Simple::Label.new(text => "Goodbye, World!") );
$app.run;
Library: Gtk#
Works with: niecza
# 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;

Phix[edit]

Library: pGUI
include pGUI.e
IupOpen()
IupMessage("Bye","Goodbye, World!")
IupClose()

PHP[edit]

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

PicoLisp[edit]

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

PostScript[edit]

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

PowerBASIC[edit]

Works with: PB/Win
FUNCTION PBMAIN() AS LONG
MSGBOX "Goodbye, World!"
END FUNCTION

PowerShell[edit]

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

Processing[edit]

Uses default Processing methods and variables.

  text("Goodbye, World!",0,height/2);

Prolog[edit]

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

PureBasic[edit]

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

Using the Windows API:

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

Pure Data[edit]

#N canvas 321 432 450 300 10;
#X obj 100 52 loadbang;
#X msg 100 74 Goodbye\, World!;
#X obj 100 96 print -n;
#X connect 0 0 1 0;
#X connect 1 0 2 0;
  • While there is no easy (intuitive) way to print a comma (or semicolon) this pd script will do.
  • When writing messages to the terminal window, Pd prepends the name of the print object and a colon, or "print: " if no name is specified, which can be avoided by using "-n" instead of a name. This behaviour, however, has not been adopted by Pd-extended :-(

Python[edit]

Works with: Python version 2.x

Library: Tkinter
[edit]

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
[edit]

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
[edit]

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: VPython
[edit]

Works with: Python version 2.7.5
 
# HelloWorld for VPython - HaJo Gurt - 2014-09-20
from visual import *
 
scene.title = "VPython Demo"
scene.background = color.gray(0.2)
 
scene.width = 600
scene.height = 400
scene.range = 4
#scene.autocenter = True
 
S = sphere(pos=(0,0,0), radius=1, material=materials.earth)
rot=0.005
 
txPos=(0, 1.2, 0)
 
from visual.text import *
# Old 3D text machinery (pre-Visual 5.3): numbers and uppercase letters only:
T1 = text(pos=txPos, string='HELLO', color=color.red, depth=0.3, justify='center')
 
import vis
# new text object, can render text from any font (default: "sans") :
T2 = vis.text(pos=txPos, text="Goodbye", color=color.green, depth=-0.3, align='center')
T2.visible=False
 
Lbl_w = label(pos=(0,0,0), text='World', color=color.cyan,
xoffset=80, yoffset=-40) # in screen-pixels
 
L1 = label(pos=(0,-1.5,0), text='Drag with right mousebutton to rotate view', box=0)
L2 = label(pos=(0,-1.9,0), text='Drag up+down with middle mousebutton to zoom', box=0)
L3 = label(pos=(0,-2.3,0), text='Left-click to change', color=color.orange, box=0)
 
print "Hello World" # Console
 
 
cCount = 0
def change():
global rot, cCount
cCount=cCount+1
print "change:", cCount
rot=-rot
if T1.visible:
T1.visible=False
T2.visible=True
else:
T1.visible=True
T2.visible=False
 
scene.bind( 'click', change )
 
while True:
rate(100)
S.rotate( angle=rot, axis=(0,1,0) )
 
 

Library: WxPython
[edit]

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

RapidQ[edit]

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

R[edit]

Library: GTK

Rather minimalist, but working...

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

Racket[edit]

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

Rascal[edit]

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

Output: Goodbyeworld.png

REALbasic[edit]

 
MsgBox("Goodbye, World!")
 

REBOL[edit]

alert "Goodbye, World!"

Red[edit]

>> view [ text "Hello World !"]

REXX[edit]

version 1[edit]

This REXX example only works with:

  •   PC/REXX
  •   Personal REXX
/*REXX (using 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, all we're done. */

output

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

version 2[edit]

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 program shows a "hello world" window (and another to show how to close)*/
parse upper version !ver .;  !pcrexx= !ver=='REXX/PERSONAL' | !ver=='REXX/PC'
if ¬!pcrexx then call ser "This isn't PC/REXX" /*this isn't PC/REXX ? */
rxWin=fcnPkg('rxwindow') /*is the function around?*/
 
if rxWin¬==1 then do 1; 'RXWINDOW /q'
if fcnPkg('rxwindow')==1 then leave /*the 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
do forever; if inKey()=='1b'x then leave; end
/* ↑ */
call w_close w /* └──◄ the ESCape key.*/
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 all done. */

Ring[edit]

 
Load "guilib.ring"
New qApp {
new qWidget() {
setwindowtitle("Hello World")
show()
}
exec()
}
 

Ruby[edit]

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
Library: Gosu
 
require 'gosu'
 
class Window < Gosu::Window
 
def initialize
super(150, 50, false)
@font = Gosu::Font.new(self, "Arial", 32)
end
 
def draw
@font.draw("Hello world", 0, 10, 1, 1, 1)
end
 
end
 
Window.new.show
Library: Green shoes
 
#_Note: this code must not be executed through a GUI
require 'green_shoes'
 
Shoes.app do
para "Hello world"
end
 
Library: Win32ole
 
require 'win32ole'
WIN32OLE.new('WScript.Shell').popup("Hello world")
 

Run BASIC[edit]

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

Rust[edit]

Rust[edit]

Library: GTK
[edit]

// cargo-deps:  gtk
extern crate gtk;
use gtk::traits::*;
use gtk::{Window, WindowType, WindowPosition};
use gtk::signal::Inhibit;
 
fn main() {
gtk::init().unwrap();
let window = Window::new(WindowType::Toplevel).unwrap();
 
window.set_title("Goodbye, World!");
window.set_border_width(10);
window.set_window_position(WindowPosition::Center);
window.set_default_size(350, 70);
window.connect_delete_event(|_,_| {
gtk::main_quit();
Inhibit(false)
});
 
window.show_all();
gtk::main();
}

Scala[edit]

Library: scala.swing

Ad hoc REPL solution[edit]

Ad hoc solution as REPL script:

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

JVM Application[edit]

Longer example, as an application:

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

.Net Framework[edit]

import swing._
 
object HelloDotNetWorld {
def main(args: Array[String]) {
System.Windows.Forms.MessageBox.Show
("Goodbye, World!")
}
}

Scilab[edit]

messagebox("Goodbye, World!")

Scheme[edit]

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)
 

Scratch[edit]

Scratch Hello World Graphical.png

Seed7[edit]

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;

Sidef[edit]

Library: Tk
var tk = require('Tk');
var main = %s'MainWindow'.new;
main.Button(
'-text' => 'Goodbye, World!',
'-command' => 'exit',
).pack;
tk.MainLoop;
Library: Gtk2
var gtk2 = require('Gtk2') -> init;
 
var window = %s'Gtk2::Window'.new;
var label = %s'Gtk2::Label'.new('Goodbye, World!');
 
window.set_title('Goodbye, World!');
window.signal_connect(destroy => func(*_){ gtk2.main_quit });
 
window.add(label);
window.show_all;
 
gtk2.main;

Smalltalk[edit]

Works with: GNU Smalltalk
MessageBox show: 'Goodbye, world.'
Works with: Smalltalk/X
Dialog information: 'Goodbye, world.'

SSEM[edit]

Ok, I know this is cheating. But it isn't completely cheating: the SSEM uses Williams tube storage, so the memory is basically a CRT device; and this is an executable program, up to a point, because the first line includes a 111 Stop instruction (disguised as a little flourish joining the tops of the d and the b).

01100000000001110000000000000000
10000000000001010000000000000000
10011101110111011101010111000000
10010101010101010101010101000000
10010101010101010101010111000000
10011101110111011100110100000010
10000000000000000000010011000010
10011000000000000000100000000100
01101000000000000001000000000000
00000000000000000000000000000000
00000000000000000000000000000000
00100100100000000010000100100000
00100100100000000010000100100000
00100100101110111010011100100000
00100100101010100010010100100000
00100100101010100010010100000000
00100100101110100011011100100000
00011011000000000000000000000000

Once you've keyed it in, the first eighteen words of storage will look a bit like this:

 oo          ooo
o            o o
o  ooo ooo ooo ooo o o ooo
o  o o o o o o o o o o o o
o  o o o o o o o o o o ooo
o  ooo ooo ooo ooo  oo o      o
o                    o  oo    o
o  oo               o        o
 oo o              o


  o  o  o         o    o  o
  o  o  o         o    o  o
  o  o  o ooo ooo o  ooo  o
  o  o  o o o o   o  o o  o
  o  o  o o o o   o  o o
  o  o  o ooo o   oo ooo  o
   oo oo

Stata[edit]

window stopbox note "Goodbye, World!"

Supernova[edit]

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

Swift[edit]

Translation of: Objective-C
import Cocoa
 
let alert = NSAlert()
alert.messageText = "Goodbye, World!"
alert.runModal()

Tcl[edit]

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]

Note: If you name this program "button.tcl", you might get strange errors.
Don't use the name of any internal tcl/tk-command as a filename for a tcl-script.

This shows our text in a message box:

tk_messageBox -message "Goodbye, World"

TI-83 BASIC[edit]

PROGRAM:GUIHELLO
:Text(0,0,"GOODBYE, WORLD!")

TI-89 BASIC[edit]

Dialog
Text "Goodbye, World!"
EndDlog

TXR[edit]

Microsoft Windows[edit]

(with-dyn-lib "user32.dll"
(deffi messagebox "MessageBoxW" int (cptr wstr wstr uint)))
 
(messagebox cptr-null "Hello" "World" 0) ;; 0 is MB_OK

VBScript[edit]

 
MsgBox("Goodbye, World!")
 

Vedit macro language[edit]

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!`")

UNIX Shell[edit]

In a virtual terminal[edit]

Using whiptail or dialog

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

In a graphical environment[edit]

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

Visual Basic[edit]

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

Visual Basic .NET[edit]

Works with: Visual Basic version 2005
Module GoodbyeWorld
Sub Main()
Messagebox.Show("Goodbye, World!")
End Sub
End Module

Visual FoxPro[edit]

* Version 1:
MESSAGEBOX("Goodbye, World!")
 
* Version 2:
? "Goodbye, World!"

X86 Assembly[edit]

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 [email protected]
extern [email protected]
 
MessageBox equ [email protected]
ExitProcess equ [email protected]
 
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
 

Web 68[edit]

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

XSLT[edit]

The output is an SVG document. The idea is that it's straightforward to use XSLT to turn an existing SVG into an instantiable template.

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="xml"/>
<xsl:template match="/*">
<!--
Use a template to insert some text into a simple SVG graphic
with hideous colors.
-->
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 200">
<rect x="0" y="0" width="400" height="200" fill="cyan"/>
<circle cx="200" cy="100" r="50" fill="yellow"/>
<text x="200" y="115"
style="font-size: 40px;
text-align: center;
text-anchor: middle;
fill: black;">

<!-- The text inside the element -->
<xsl:value-of select="."/>
</text>
</svg>
</xsl:template>
</xsl:stylesheet>

Sample input:

<message>Goodbye, World!</message>

Sample output (with formatting non-destructively adjusted):

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 200">
<rect x="0" y="0" width="400" height="200" fill="cyan"/>
<circle cx="200" cy="100" r="50" fill="yellow"/>
<text x="200" y="115" style="font-size: 40px;
text-align: center;
text-anchor: middle;
fill: black;">
Goodbye, World!</text>
</svg>

zkl[edit]

zkl doesn't have a decent GUI ffi but, on my Linux box, the following work:

System.cmd(0'|zenity --info --text="Goodbye, World!"|); // GTK+ pop up
System.cmd(0'|notify-send "Goodbye, World!"|); // desktop notification
System.cmd(0'|xmessage -buttons Ok:0,"Not sure":1,Cancel:2 -default Ok -nearmouse "Goodbye, World!" -timeout 10|); // X Windows dialog

The quote quote syntax is 0'<char>text<char> or you can use \ (eg "\"Goodbye, World!\"")