Hello world/Text

Hello world/Text
You are encouraged to solve this task according to the task description, using any language you may know.

Hello world/Text is part of Short Circuit's Console Program Basics selection.

In this User Output task, the goal is to display the string "Goodbye, World!" [sic] on a text console.

See also

• Hello world/Graphical
• Hello world/Line Printer
• Hello world/Newline omission
• Hello world/Standard error
• Hello world/Web server

0815

 
<:47:x<:6F:=<:64:$=$$=$
<:62:x<:79:=<:65:$=$=$
<:2C:x<:20:=<:57:$=$=$
<:6F:x<:72:=<:6C:$=$=$
<:64:x<:21:=<:0D:$=$=$
 
 

360 Assembly

Using native SVC (Supervisor Call) to write to system console:

         LA    1,MSGAREA     Point Register 1 to message area
         SVC   35            Invoke SVC 35 (Write to Operator) 
         BR    14            Return
MSGAREA  EQU   *             Message Area
         DC    AL2(19)       Total area length = 19 (Prefix length:4 + Data Length:15) 
         DC    XL2'00'       2 bytes binary of zeros
         DC    C'Goodbye, World!'  Text to be written to system console
         END

Using WTO Macro to generate SVC 35 and message area:

         WTO   'Goodbye, World!'
         BR    14            Return
         END

4DOS Batch

echo Goodbye, World!

6502 Assembly

; goodbyeworld.s for C= 8-bit machines, ca65 assembler format.
; String printing limited to strings of 256 characters or less.
 
a_cr	= $0d		; Carriage return.
bsout	= $ffd2		; KERNAL ROM, output a character to current device.
 
	.code
 
	ldx #0		; Starting index 0 in X register.
printnext:
	lda text,x	; Get character from string.
	beq done	; If we read a 0 we're done.
	jsr bsout	; Output character. 
	inx		; Increment index to next character.
	bne printnext	; Repeat if index doesn't overflow to 0.
done:
	rts		; Return from subroutine.
 
	.rodata
 
text:
	.byte	"Goodbye, World!", a_cr, 0

6800 Assembly

        .cr  6800
        .tf  gbye6800.obj,AP1
        .lf  gbye6800
;=====================================================;
;        Goodbye, World! for the Motorola 6800        ;
;                 by barrym 2013-03-17                ;
;-----------------------------------------------------;
; Prints the message "Goodbye, World!" to an ascii    ;
;   terminal (console) connected to a 1970s vintage   ;
;   SWTPC 6800 system, which is the target device for ;
;   this assembly.                                    ;
; Many thanks to:                                     ;
;   swtpc.com for hosting Michael Holley's documents! ;
;   sbprojects.com for a very nice assembler!         ;
;   swtpcemu.com for a very capable emulator!         ;
; reg x is the string pointer                         ;
; reg a holds the ascii char to be output             ;
;-----------------------------------------------------;
outeee   =   $e1d1      ;ROM: console putchar routine
        .or  $0f00
;-----------------------------------------------------;
main    ldx  #string    ;Point to the string
        bra  puts       ;  and print it
outs    jsr  outeee     ;Emit a as ascii
        inx             ;Advance the string pointer
puts    ldaa ,x         ;Load a string character
        bne  outs       ;Print it if non-null
        swi             ;  else return to the monitor
;=====================================================;
string  .as  "Goodbye, World!",#13,#10,#0
        .en

8086 Assembly

DOSSEG
.MODEL TINY
.DATA
TXT DB "Goodbye, World!$"
.CODE
START:
	MOV ax, @DATA
	MOV ds, ax
 
	MOV ah, 09h		; prepare output function
	MOV dx, OFFSET TXT	; set offset
	INT 21h			; output string TXT
 
	MOV AX, 4C00h 		; go back to DOS
	INT 21h
END START

With A86 or NASM syntax:

  org 100h

  mov dx, msg
  mov ah, 9
  int 21h

  mov ax, 4c00h
  int 21h

msg:
  db "Goodbye, World!$"

ABAP

REPORT zgoodbyeworld.
  WRITE 'Goodbye, World!'.

ACL2

(cw "Goodbye, World!~%")

ActionScript

trace("Goodbye, World!");

Ada

Works with: GCC version 4.1.2

with Ada.Text_IO; use Ada.Text_IO;
procedure Main is
begin
  Put_Line ("Goodbye, World!");
end Main;

Aime

o_text("Goodbye, World!\n");

or:

integer
main(void)
{
    o_text("Goodbye, World!\n");
 
    return 0;
}

Algae

printf("Goodbye, World\n");

ALGOL 60

'BEGIN'
    OUTSTRING(1,'('GOODBYE, WORLD!')');
    SYSACT(1,14,1)
'END'

ALGOL 68

main: (
  printf($"Goodbye, World!"l$)
)

Alore

Print('Goodbye, World!')

AmbientTalk

system.println("Goodbye, World!")

AmigaE

PROC main()
  WriteF('Goodbye, World!\n')
ENDPROC

AppleScript

To show in Script Editor Result pane:

"Goodbye, World!"

To show in Script Editor Event Log pane:

log "Goodbye, World!"

Applesoft BASIC

Important Note: Although Applesoft BASIC allowed the storage and output of mixed-case strings, the ability to enter mixed-case via the keyboard and to output mixed-case on the default display was not offered as standard equipment on the original Apple II/II+. Since Applesoft WAS the default programming language for the Apple II+, perhaps some flexibility in the task specification could be offered, for this and for other systems that lacked proper mixed-case I/O capabilities in at least one popular configuration.

 PRINT "GOODBYE, WORLD!"

Apricot

(puts "Goodbye, World!")

Argile

use std
print "Goodbye, World!"

compile with: arc hello_world.arg -o hello_world.c && gcc -o hello_world hello_world.c

Asymptote

write('Goodbye, World!');

ATS

implement main0 () = print "Goodbye, World!\n"

AutoHotkey

script launched from windows explorer

DllCall("AllocConsole")
FileAppend, Goodbye`, World!, CONOUT$
FileReadLine, _, CONIN$, 1

scripts run from shell [requires Windows XP or higher; older Versions of Windows don´t have the "AttachConsole" function]

DllCall("AttachConsole", "int", -1)
FileAppend, Goodbye`, World!, CONOUT$

SendInput Goodbye, World{!}

AutoIt

ConsoleWrite("Goodbye, World!" & @CRLF)

AWK

BEGIN{print "Goodbye, World!"}

"BEGIN" is a "special pattern" - code within "{}" is executed before the input file is read, even if there is no input. "END" is a similar pattern, for after completion of main processing.

 
END {
     print "Goodbye, World!"
    }
 

For a file containing data, the work can be done in the "body". The "//" is "match anything" so gets the first data, the "exit" halts processing the file (any "END" would then be executed).

 
//  { 
    print "Goodbye, World!" 
    exit
    }
 

For a "single record" file.

 
//  { 
    print "Goodbye, World!" 
    }
 

For a "single record" file containing - Goodbye, World! -. The "default" action for a "pattern match" (the "/" and "/" define a "pattern" to match data) is to "print" the record.

 
// 
 

Babel

((main { "Goodbye, World!" << }))

BASIC

Works with: BASICA

Works with: Locomotive Basic

Works with: ZX Spectrum Basic

10 PRINT "Goodbye, World!"

Works with: 7Basic

Works with: QBasic

PRINT "Goodbye, World!"

bash

echo "Goodbye, World!"

BASIC256

PRINT "Goodbye, World!"

Battlestar

const hello = "Goodbye, World!\n"
 
print(hello)

Batch File

Under normal circumstances, when delayed expansion is disabled

echo Goodbye, World!

If delayed expansion is enabled, then the ! must be escaped twice

setlocal enableDelayedExpansion
echo Goodbye, World^^^!

BBC BASIC

      PRINT "Goodbye, World!"

bc

"Goodbye, World!
"

BCPL

GET "libhdr"
 
LET start() = VALOF
{ writef("Goodbye, World!")
  RESULTIS 0
}

Befunge

0"!dlroW ,eybdooG">:#,_@

Blast

# This will display a goodbye message on the terminal screen
.begin
display "Goodbye, World!"
return
# This is the end of the script.

BML

display "Goodbye, World!"

Boo

print "Goodbye, World!"

Brace

#!/usr/bin/env bx
use b
Main:
	say("Goodbye, World!")

Brainf***

To print text, we need the ascii-value of each character to output.
So, we wanna make a series of round numbers going like:

10	close to newline and carriage return
30	close to ! and SPACE
40	close to COMMA
70	close to G
80	close to W
90	close to b
100	is d and close to e and l
110	close to o
120	close to y

forming all the letters we need if we just add up a bit

Commented version:

+++++ +++++		First cell 10 (its a counter and we will be "multiplying")
 
[
>+			10 times 1 is 10
>+++			10 times 3 is 30
>++++			etc etc
>+++++ ++
>+++++ +++
>+++++ ++++
>+++++ +++++
>+++++ ++++++
>+++++ +++++++
<<<<<<<<< -		go back to counter and subtract 1
]
 
printing G
>>>> + .
 
o twice
>>>> + ..
 
d
< .
 
b
< +++++ +++ .
 
y
>>> + .
 
e
<< + .
 
COMMA
<<<< ++++ .
 
SPACE
< ++ .
 
W
>>> +++++ ++ .
 
o
>>> .
 
r
+++ .
 
l
< +++++ ++ .
 
d
----- --- .
 
!
<<<<< + .
 
CRLF
< +++ . --- .

Uncommented:

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

It can most likely be optimized, but this is a nice way to show how character printing works in Brainf*** :)

Bracmat

put$"Goodbye, World!"

Brat

p "Goodbye, World!"

Brlcad

The mged utility can output text to the terminal:

 
echo Goodbye, World!
 

Burlesque

 
"Goodbye, World!"sh
 

Although please note that sh actually does not print anything.

C

Works with: gcc version 4.0.1

#include <stdlib.h>
#include <stdio.h>
 
int main(void)
{
  printf("Goodbye, World!\n");
  return EXIT_SUCCESS;
}

Or:

#include <stdlib.h>
#include <stdio.h>
 
int main(void)
{
  puts("Goodbye, World!");
  return EXIT_SUCCESS;
}

Or, the eternal favourite :)

 
#include<stdio.h>
 
int main()
{
  printf("\nGoodbye, World!");
  return 0;
}

C#

Works with: Mono version 1.2

Works with: Visual C# version 2003

namespace HelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            System.Console.WriteLine("Goodbye, World!");
        }
    }
}

ChucK

<<< "Goodbye, World!">>>;

C++

#include <iostream>
 
int main () {
  std::cout << "Goodbye, World!\n";
}

C++/CLI

using namespace System;
int main()
{
  Console::WriteLine("Goodbye, World!");
}

C1R

Hello_world/Text

Output:

$ echo Hello_world/Text >hw.c1r
$ ./c1r hw.c1r
$ ./a.out
Goodbye, World!

Cat

"Goodbye, World!" writeln

Cduce

print "Goodbye, World!";;

Chef

Goodbye World Souffle.
 
Ingredients.
71 g green beans
111 cups oil
98 g butter
121 ml yogurt
101 eggs
44 g wheat flour
32 zucchinis
119 ml water
114 g red salmon
108 g lard
100 g dijon mustard
33 potatoes
 
Method.
Put potatoes into the mixing bowl.
Put dijon mustard into the mixing bowl.
Put lard into the mixing bowl.
Put red salmon into the mixing bowl.
Put oil into the mixing bowl.
Put water into the mixing bowl.
Put zucchinis into the mixing bowl.
Put wheat flour into the mixing bowl.
Put eggs into the mixing bowl.
Put yogurt into the mixing bowl.
Put butter into the mixing bowl.
Put dijon mustard into the mixing bowl.
Put oil into the mixing bowl.
Put oil into the mixing bowl.
Put green beans into the mixing bowl.
Liquefy contents of the mixing bowl.
Pour contents of the mixing bowl into the baking dish.
 
Serves 1.

Clay

main() {
    println("Goodbye, World!");
}

Clean

Start = "Goodbye, World!"

Clipper

? "Goodbye, World!"

CLIPS

(printout t "Goodbye, World!" crlf)

Clojure

(println "Goodbye, World!")

CMake

message(STATUS "Goodbye, World!")

This outputs

-- Goodbye, World!

COBOL

Using fixed format.

Works with: OpenCOBOL

	program-id. hello.
	procedure division.
		display "Goodbye, World!".
		stop run.

Cobra

class Hello
    def main
        print 'Goodbye, World!'

CoffeeScript

Works with: Node.js

console.log "Goodbye, World!"

Works with: Rhino engine

print "Goodbye, World!"

ColdFusion

<cfoutput>Goodbye, World!</cfoutput>

Common Lisp

(format t "Goodbye, World!~%")

Component Pascal

 
MODULE Hello;
	IMPORT Out;
 
	PROCEDURE Do*;
	BEGIN
		Out.String("Goodbye, World!"); Out.Ln
	END Do;
END Hello.

Run command Hello.Do by commander.

Crack

 
import crack.io cout;
cout `Goodbye, World!\n`;
 

Creative Basic

 
OPENCONSOLE
 
PRINT"Goodbye, World!"
 
'This line could be left out.
PRINT:PRINT:PRINT"Press any key to end."
 
'Keep the console from closing right away so the text can be read.
DO:UNTIL INKEY$<>""
 
CLOSECONSOLE
 
END
 

Crystal

puts "Goodbye, World!"

D

Works with: D version 2.0

import std.stdio;
 
void main() {
    writeln("Goodbye, World!");
}

Dao

io.writeln( 'Goodbye, World!' )

Dart

main() {
    var bye = 'Goodbye, World!';
    print("$bye");
}

dc

[Goodbye, World!]p

DDNC

DDNC can only output to a single 7-segment LED display digit, so first we must convert each character into its 7-segment equivalent numerical value.

The three horizontal bars are assigned bits 6, 3, and 0 from top to bottom. The top two vertical bars are assigned bits 5 and 4 while the bottom two vertical bars are assigned bits 2 and 1 from left to right.

Because DDNC can only interpret literals in decimal, each binary number was converted and stored in consecutive memory cells starting at cell 10.

The code can be divided into three sections. The first stores the character numbers in order in an array. The second sets up the loop by loading a delay of 500 milliseconds to slot 3, the start address of the character array in memory to slot 2, and the number of times to loop (14) plus one to slot 5. The third section starts the loop of displaying the characters, waiting for the delay time, incrementing the pointer, decrementing the counter, and checking if the counter is negative to know whether to continue the loop.

 
0 111 10
0 15 11
0 15 12
0 31 13
0 47 14
0 59 15
0 125 16
0 3 17
0 0 18
0 63 19
0 15 20
0 12 21
0 36 22
0 31 23
0 17 24
 
0 500 3
0 10 2
0 15 5
 
60 4
2 2 1
80 1
72 3
30 2
31 5
62 5
61 4
64
 

Déjà Vu

!print "Goodbye, World!"

Delphi

 
program ProjectGoodbye;
{$APPTYPE CONSOLE}
begin
  WriteLn('Goodbye, World!');
end.
 

DWScript

 
PrintLn('Goodbye, World!');
 

Dylan

 
module: hello-world
 
format-out("%s\n", "Goodbye, World!");
 

Dylan.NET

Works with: Mono version 2.6.7

Works with: Mono version 2.10.x

Works with: Mono version 3.x.y

Works with: .NET version 3.5

Works with: .NET version 4.0

Works with: .NET version 4.5

One Line version:

Console::WriteLine("Goodbye, World!")

Hello World Program:

 
//compile using the new dylan.NET v, 11.5.1.2 or later
//use mono to run the compiler
#refstdasm mscorlib.dll
 
import System
 
assembly helloworld exe
ver 1.2.0.0
 
class public Program
 
   method public static void main()
      Console::WriteLine("Goodbye, World!")
   end method
 
end class
 

E

println("Goodbye, World!")
 
stdout.println("Goodbye, World!")

eC

class GoodByeApp : Application
{
   void Main()
   {
      PrintLn("Goodbye, World!");
   }
}

ECL

 
OUTPUT('Goodbye, World!');
 

Efene

short version (without a function)

io.format("Goodbye, World!~n")

complete version (put this in a file and compile it)

@public 
run = fn () {
    io.format("Goodbye, World!~n")
}

Egison

 
(define $main
  (lambda [$argv]
    (write-string "Goodbye, World!\n")))
 

Eiffel

This page uses content from Wikipedia. The original article was at Eiffel (programming language). The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance)

class
    HELLO_WORLD
create
    make
feature
    make
        do
            print ("Goodbye, World!%N")
        end
end

Ela

open console
writen "Goodbye, World!"

elastiC

From the elastiC Manual.

package hello;
 
    // Import the `basic' package
    import basic;
 
    // Define a simple function
    function hello()
    {
        // Print hello world
        basic.print( "Goodbye, World!\n" );
    }
 
    /*
     *  Here we start to execute package code
     */
 
    // Invoke the `hello' function
    hello();

Elena

#symbol Program =
[
    system'console writeLine:"Goodbye, World!".
].

Elena Script

[[
   #define start ::= "?" < system'console.eval&writeLine( > $literal < ) >; 
]]
 
? "Hello World!!"
 

Elisa

 "Goodbye, World!"? 

Elixir

 
IO.puts "Goodbye, World!"
 

Elm

main = plainText "Goodbye World!"

Emacs Lisp

(insert "Goodbye, World!")

Erlang

io:format("Goodbye, World!~n").

ERRE

 
! Hello World in ERRE language
PROGRAM HELLO
BEGIN
  PRINT("Hello World !")
END PROGRAM
 

EGL

Works with: EDT

Works with: RBD

 
program HelloWorld
    function main()
        SysLib.writeStdout("Goodbye, World!");
    end
end
 

Euler Math Toolbox

"Goodbye, World!"

Extended BrainF***

[.>]@Goodbye, World!

Ezhil

பதிப்பி"வணக்கம் உலகம்!"
பதிப்பி "Goodbye, World!"
பதிப்பி"******* வணக்கம்! மீண்டும் சந்திப்போம் *******"
exit()

F#

printfn "%s" "Goodbye, World!"

or using .Net classes directly

System.Console.WriteLine("Goodbye, World!")

Factor

"Goodbye, World!" print

Falcon

With the printl() function:

printl("Goodbye, World!")

Or via "fast print":

> "Goodbye, World!"

FALSE

"Goodbye, World!
"

Fantom

 
class HelloText
{
  public static Void main ()
  {
    echo ("Goodbye, World!")
  }
}
 

ferite

word.}}

uses "console";
Console.println( "Goodby, World!" );

Fexl

say "Goodbye, World!"

Fish

Standard Hello, world example, modified for this task:

!v"Goodbye, World!"r!
 >l?!;o

Explanation of the code:
!v" jumps over the v character with the ! sign, then starts the string mode with " .
Then the characters Goodbye, World! are added, and string mode is closed with ".
The stack is reversed for printing (r), and a jump (!) is executed to jump over the ! at the beginning of the line and execute the v. (Fish is torical)
After going down by v, it goes rightwards again by > and this line is being executed.
This line pushes the stack size (l), and stops (;) if the top item on the stack is equal to 0 (?). Else it executes the ! directly after it and jumps to the o, which outputs the top item in ASCII. Then the line is executed again. It effectively prints the stack until it's empty, then it terminates.

Forth

." Goodbye, World!"

Or as a whole program:

: goodbye ( -- )   ." Goodbye, World!" CR ;

Fortran

Works with: F77

Simplest case - display using default formatting:

print *,"Goodbye, World!"

Use explicit output format:

100   format (5X,A,"!")
      print 100,"Goodbye, World!"

Output to channels other than stdout goes like this:

write (89,100) "Goodbye, World!"

uses the format given at label 100 to output to unit 89. If output unit with this number exists yet (no "OPEN" statement or processor-specific external unit setting), a new file will be created and the output sent there. On most UNIX/Linux systems that file will be named "fort.89".

Fortress

export Executable                                                                                                                       
 
run() = println("Goodbye, World!")

Frege

Works with: Frege version 3.20.113

module HelloWorld where
main _ = println "Goodbye, World!"

friendly interactive shell

Unlike other UNIX shell languages, fish doesn't support history substitution, so ! is safe to use without quoting.

echo Goodbye, World!

Frink

 
println["Goodbye, World!"]
 

FunL

println( 'Goodbye, World!' )

Gambas

 
PRINT "Goodbye, World!"
 

GML

show_message("Goodbye, World!"); // displays a pop-up message
show_debug_message("Goodbye, World!"); // sends text to the debug log or IDE

GAP

# Several ways to do it
"Goodbye, World!";
 
Print("Goodbye, World!\n"); # No EOL appended
 
Display("Goodbye, World!");
 
f := OutputTextUser();
WriteLine(f, "Goodbye, World!\n");
CloseStream(f);

gecho

'Goodbye, <> 'World! print

Gema

Gema ia a preprocessor that reads an input file and writes an output file. This code will write "Goodbye, World!' no matter what input is given.

*= ! ignore off content of input
\B=Goodbye, World\! ! Start output with this text.

Gentee

func hello <main>
{
   print("Goodbye, World!")
}

GLBasic

STDOUT "GOODBYE, WORLD!"

Glee

"Goodbye, World!"

or

'Goodbye, World!'

or to display with double quotes

 '"Goodbye,World!"'

or to display with single quotes

 "'Goodbye,World!'"

Go

package main
 
import "fmt"
 
func main() { fmt.Println("Goodbye, World!") }

Golfscript

"Goodbye, World!"

Gosu

print("Goodbye, World!")

Groovy

println "Goodbye, World!"

GW-BASIC

10 PRINT "Goodbye, World!"

Hack

<?hh echo 'Goodbye, World!'; ?>

Harbour

? "Goodbye, World!"

Haskell

main = putStrLn "Goodbye, World!"

Haxe

trace("Goodbye, World!");

HicEst

WRITE() 'Goodbye, World!'

HLA

program goodbyeWorld;
#include("stdlib.hhf")
begin goodbyeWorld;
 
  stdout.put( "Goodbye, World!" nl );
 
end goodbyeWorld;

HQ9+

This example is incorrect. output isn't consistent with the task's requirements (and is probably incapable of solving the task). Please fix the code and remove this message.

H

• Technically, HQ9+ can't print "Goodbye, world!" text because of its specification.

- H : Print 'Hello World!'
- Q : Quine
- 9 : Print '99 Bottles of Beer'
- + : Increase Pointer (useless!)

Icon and Unicon

procedure main()
  write( "Goodbye, World!" )
end

IDL

print,'Goodbye, World!'

Inform 6

[Main;
  print "Goodbye, World!^";
];

Integer BASIC

NOTE: Integer BASIC was written (and hand-assembled by Woz himself) for the Apple 1 and original Apple 2. The Apple 1 has NO support for lower-case letters, and it was an expensive (and later) option on the Apple 2. This example accurately represents the only reasonable solution for those target devices, and therefore cannot be "fixed", only deleted.

   10 PRINT "GOODBYE, WORLD!"
   20 END

Io

"Goodbye, World!" println

Ioke

"Goodbye, World!" println

IWBASIC

 
OPENCONSOLE
 
PRINT"Goodbye, World!"
 
'This line could be left out.
PRINT:PRINT:PRINT"Press any key to end."
 
'Keep the console from closing right away so the text can be read.
DO:UNTIL INKEY$<>""
 
CLOSECONSOLE
 
END
 

J

   'Goodbye, World!'
Goodbye, World!

Here are some redundant alternatives:

   [data=. 'Goodbye, World!'
Goodbye, World!
   data
Goodbye, World!
   smoutput data
Goodbye, World!

Java

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

Jacquard Loom

This weaves the string "Goodbye, World!"

+---------------+
|               |
|    *    *     |
|*   *    *  *  |
|*           * *|
|*           * *|
|*  *         * |
|   *     *   * |
|         *     |
+---------------+
 
+---------------+
|               |
|*   *    *     |
|*   *    *     |
|            * *|
|            * *|
|*  *         * |
|*  *     *   * |
|         *     |
+---------------+
 
+---------------+
|               |
|*   **   * *   |
|*******  *** * |
| **** *   * ***|
| **** *  ******|
| ******   ** * |
|   * *   *   * |
|         *     |
+---------------+
 
+---------------+
|               |
|*******  *** * |
|*******  *** * |
|           ** *|
|*        *  * *|
|*******   ** * |
|*******  *** * |
|         *     |
+---------------+
 
+---------------+
|               |
|*******  *** * |
|*******  *** * |
|      *  *  * *|
|      *  *  * *|
|*******  **  * |
|*******  **  * |
|         *     |
+---------------+
 
+---------------+
|               |
|***** *  *** * |
|*******  *** * |
|     * * *  *  |
|     * *    *  |
|******   **  * |
|******   **  * |
|         *     |
+---------------+
 
+---------------+
|               |
|    *    * *   |
|***** *  ***** |
|***** **  * ***|
|***** **  * ***|
|*******   * ** |
|   * *   *   * |
|         *     |
+---------------+
 
+---------------+
|               |
|               |
|     * *       |
|     * *       |
|     *         |
|     *         |
|               |
|               |
+---------------+

JavaScript

document.write("Goodbye, World!");

Works with: NJS version 0.2.5

Works with: Rhino

Works with: SpiderMonkey

print('Goodbye, World!');

Works with: JScript

WScript.Echo("Goodbye, World!");

Works with: Node.js

console.log("Goodbye, World!")

JCL

/*MESSAGE Goodbye, World!

Joy

"Goodbye, World!" putchars.

jq

"Goodbye, World!"

Julia

println("Goodbye, World!")

Kaya

program hello;
 
Void main() {
    // My first program!
    putStrLn("Goodbye, World!");
}

Kdf9 Usercode

This example is incorrect. output isn't consistent with the task's requirements: wording, punctuation. Please fix the code and remove this message.

 
 
V2; W0;
RESTART; J999; J999;
PROGRAM;                   (main program);
   V0 = Q0/AV1/AV2;
   V1 = B0750064554545700; ("Hello" in Flexowriter code);
   V2 = B0767065762544477; ("World" in Flexowriter code);
   V0; =Q9; POAQ9;         (write "Hello World" to Flexowriter);
999;  OUT;
   FINISH;
 

Kite

simply a single line

"#!/usr/local/bin/kite
 
"Goodbye, World!"|print;

Kitten

"Goodbye, World!" say

KonsolScript

Displays it in a text file or console/terminal.

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

Lasso

A plain string is output automatically.

'Goodbye, World!'

Lang5

"Goodbye, World!\n" .

LFE

 
(: io format '"Goodbye, World!~n")
 

Liberty BASIC

print "Goodbye, World!"

Limbo

implement Command;
 
 include "sys.m";
     sys: Sys;
 
 include "draw.m";
 
 include "sh.m";
 
 init(nil: ref Draw->Context, nil: list of string)
 {
     sys = load Sys Sys->PATH;
     sys->print("Goodby, World!\n");
 }

Lisaac

Works with: Lisaac version 0.13.1

You can print to standard output in Lisaac by calling STRING.print or INTEGER.print:

Section Header          // The Header section is required.
  + name := GOODBYE;    // Define the name of this object.
 
Section Public
  - main <- ("Goodbye, World!\n".print;);

However, it may be more straightforward to use IO.print_string instead:

Section Header          // The Header section is required.
  + name := GOODBYE2;   // Define the name of this object.
 
Section Public
  - main <- (IO.put_string "Goodbye, World!\n";);

LLVM

@str = internal constant [14 x i8] c"Hello, world!\00"
declare i32 @puts(i8*)
define i32 @main()
{
  call i32 @puts( i8* getelementptr ([14 x i8]* @str, i32 0,i32 0))
  ret i32 0
}

Logo

Print includes a line feed:

print [Goodbye, World!]

Type does not:

type [Goodbye, World!]

Logtalk

:- object(hello_world).
 
    % the initialization/1 directive argument is automatically executed
    % when the object is loaded into memory:
    :- initialization(write('Goodbye, World!\n')).
 
:- end_object.

LOLCODE

 
HAI
CAN HAS STDIO?
VISIBLE "Goodbye, World!"
KTHXBYE
 

LotusScript

:- object(hello_world).
    'This will send the output to the status bar at the bottom of the Notes client screen
    print "Goodbye, World!"
 
:- end_object.

LSE64

"Goodbye, World!" ,t nl

Lua

Function calls with either a string literal or a table constructor passed as their only argument do not require parentheses.

print "Goodbye, World!"

Harder way with a table:

 
local chars = {"G","o","o","d","b","y","e",","," ","W","o","r","l","d","!"}
for i = 1, #chars do
write(chars[i])
end
 

M4

For the particular nature of m4, this is simply:

`Goodbye, World!'

make

Makefile contents:

 
all:
$(info Goodbye, World!)
 

Running make produces:

Goodbye, World!
make: Nothing to be done for `all'.

Malbolge

Long Version:

('&%:9]!~}|z2Vxwv-,POqponl$Hjig%eB@@>}=<M:9wv6WsU2T|nm-,jcL(I&%$#"
`CB]V?Tx<uVtT`Rpo3NlF.Jh++FdbCBA@?]!~|4XzyTT43Qsqq(Lnmkj"Fhg${z@>

Short Version:

(=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8dc

Output:

HELLO WORLD!

Maple

 
> printf( "Goodbye, World!\n" ): # print without quotes
Goodbye, World!
 

Mathematica

Print["Goodbye, World!"]

MATLAB

>> 'Goodbye, World!'
 
ans =
 
Goodbye, World!

Maude

 
fmod BYE-WORLD is
 
	protecting STRING .
 
	op sayBye : -> String .
 
	eq sayBye = "Goodbye, World!" .
 
endfm
 
red sayBye .
 

Maxima

print("Goodbye, World!");

MAXScript

print "Goodbye, World!"

or:

format "%" "Goodbye, World!"

Mercury

:- module hello.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
 
:- implementation.
main(!IO) :-
    io.write_string("Goodbye, World!\n", !IO).

Metafont

message "Goodbye, World!"; end

MIPS Assembly

Works with: MARS

and

Works with: SPIM

   .data
hello:  .asciiz "Goodbye, World!"
 
   .text
main:
   la $a0, hello
   li $v0, 4
   syscall
   li $v0, 10
   syscall

mIRC Scripting Language

echo -ag Goodbye, World!

ML/I

Goodbye, World!

Modula-2

MODULE Hello;
IMPORT InOut;
 
BEGIN
  InOut.WriteString('Goodbye, World!');
  InOut.WriteLn
END Hello.

Modula-3

MODULE Goodbye EXPORTS Main;
 
IMPORT IO;
 
BEGIN
  IO.Put("Goodbye, World!\n");
END Goodbye.

MUF

: main[ -- ]
me @ "Goodbye, World!" notify
exit
;

MUMPS

Write "Goodbye, World!",!

Mythryl

print "Goodbye, World!";

MySQL

SELECT 'Goodbye, World!';

Neat

void main() writeln "Goodbye, World!";

Nemerle

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

Easier method:

 
System.Console.WriteLine("Goodbye, World!");
 

Neko

$print("Hello, World!");

NetRexx

say  'Goodbye, World!'

newLISP

Works with: newLisp version 6.1 and after

(println "Goodbye, World!")

Nim

echo("Goodbye, World!")

Nit

print "Goodbye, World!"

Oberon-2

 
MODULE Goodbye;
IMPORT Out;
  PROCEDURE World*;
  BEGIN
    Out.String("Goodbye, World!");Out.Ln
  END World;
BEGIN
  World;
END Goodbye.
 

Objeck

 
class Hello {
  function : Main(args : String[]) ~ Nil {
    "Goodbye, World!"->PrintLine();
  }
}

Objective-C

Works with: GCC

To print to stdout:

printf("Goodbye, World!");

To print an Objective-C NSString to stdout, here are some options:

printf("%s", [@"Goodbye, World!" UTF8String]);

[@"Goodbye, World!" writeToFile:@"/dev/stdout" atomically:NO encoding:NSUTF8StringEncoding error:NULL];

[[NSFileHandle fileHandleWithStandardOutput] writeData:[@"Goodbye, World!" dataUsingEncoding:NSUTF8StringEncoding]];

To log a time-stamped message to stderr:

NSLog(@"Goodbye, World!");

OCaml

print_endline "Goodbye, World!"

Occam

Works with: kroc

#USE "course.lib"
PROC main (CHAN BYTE screen!)
  out.string("Goodbye, World!*c*n", 0, screen)
:

Octave

disp("Goodbye, World!");

Or, using C-style function printf:

printf("Goodbye, World!");

Oforth

"Goodbye, World!" println

Onyx

`Goodbye, World!\n' print

OOC

To print a String, either call its println() method:

main: func {
  "Goodbye, World!" println()
}

Or call the free println() function with the String as the argument.

main: func {
  println("Goodbye, World!")
}

ooRexx

Refer also to the Rexx and NetRexx solutions. Simple output is common to most Rexx dialects.

/* Rexx */
say 'Goodbye, World!'
 

Openscad

 
echo("Goodbye, World!");
 

Oxygene

From wp:Oxygene (programming language)

 
namespace HelloWorld;
 
interface
 
type
  HelloClass = class
  public
    class method Main; 
  end;
 
implementation
 
class method HelloClass.Main;
begin
  System.Console.WriteLine('Goodbye, World!');
end;
 
end.
 

>HelloWorld.exe
Goodbye, World!

Oz

{Show "Goodbye, World!"}

PARI/GP

print("Goodbye, World!")

Pascal

Works with: Free Pascal

program byeworld;
begin
 writeln('Goodbye, World!');
end.

PASM

print "Goodbye, World!\n"
end

PDP-11 Assembly

Works with: UNIX version 7

This is tested on Unix v7 Prints "Goodbye, World!" to stdout:

.globl  start
	.text
start:
        mov	$1,r0
	sys	4; outtext; outlen
	sys	1
	rts	pc
 
	.data
outtext: <Goodbye, World!\n>
outlen = . - outtext

Perl

Works with: Perl version 5.8.8

print "Goodbye, World!\n";

Works with: Perl version 5.10.x

Backported from Perl 6:

use feature 'say';
say 'Goodbye, World!';

or:

use 5.010;
say 'Goodbye, World!';

Perl 6

say 'Goodbye, World!';

PHL

module helloworld;
extern printf;
 
@Integer main [
    printf("Goodbye, World!");
    return 0;
]

PHP

<?php
echo "Goodbye, World!\n";
?>

Alternatively, any text outside of the <?php ?> tags will be automatically echoed:

Goodbye, World!

PicoLisp

(prinl "Goodbye, World!")

PIR

.sub hello_world_text :main
	print "Goodbye, World!\n"
.end

Pike

int main(){
   write("Goodbye, World!\n");
}

PL/I

goodbye:proc options(main);
     put list('Goodbye, World!');
end goodbye;

Pop11

printf('Goodbye, World!\n');

PostScript

The "==" and "=" operators display the topmost element of the stack with or without processing, followed by a newline. Thus:

(Goodbye, World!) ==

will display the string "(Goodbye, World!)" while

(Goodbye, World!) =

will display the content of the string "(Goodbye, World!)"; that is, "Goodbye, World!".

To print a string without the following newline, use

(Goodbye, World!) print

PowerShell

'Goodbye, World!'
 
#It's considered good practice to use Write-Host, although it works just fine without too
Write-Host 'Goodbye, World!'
 
# For extra flair, you can specify colored output
Write-Host 'Goodbye, World!' -foregroundcolor red

ProDOS

printline Goodbye, World!

Prolog

:- write('Goodbye, World!'), nl.

PSQL

 EXECUTE BLOCK
   RETURNS(S VARCHAR(40))
 AS
 BEGIN
   S = 'Goodbye, World!';
   SUSPEND;
 END

Pure

 
using system;
 
puts "Goodbye, World!\n" ;
 

PureBasic

OpenConsole()
PrintN("Goodbye, World!")
Input() ; Wait for enter

Python

Works with: Python version 2.4

print "Goodbye, World!"

The same using sys.stdout

import sys
sys.stdout.write("Goodbye, World!\n")

In Python 3.0, print is changed from a statement to a function.

Works with: Python version 3.0

(And version 2.X too).

print("Goodbye, World!")

Quill

"Goodbye, World!" print

R

 cat("Goodbye, World!\n")

Racket

 
(printf "Goodbye, World!\n")
 

Raven

'Goodbye, World!' print

REALbasic

Works with: REALbasic version 5.5

This requires a console application.

Function Run(args() as String) As Integer
  Print "Goodbye, World!"
  Quit
End Function

REBOL

print "Goodbye, World!"

RED

print "Goodbye, World!"

Retro

 
"Goodbye, World!" puts
 

REXX

using SAY

/*REXX program to show a line of text.  */
say 'Goodbye, World!'

using SAY variable

/*REXX program to show a line of text.  */
yyy = 'Goodbye, World!'
say yyy

using LINEOUT

/*REXX program to show a line of text.  */
 
call lineout ,"Goodbye, World!"

RTL/2

TITLE Goodbye World;
 
LET NL=10;
 
EXT PROC(REF ARRAY BYTE) TWRT;
 
ENT PROC INT RRJOB();
 
    TWRT("Goodbye, World!#NL#");
    RETURN(1);
 
ENDPROC;

Ruby

Works with: Ruby version 1.8.4

puts "Goodbye, World!"

or

$stdout.puts "Goodbye, World!"

or even

 STDOUT.write "Goodbye, World!\n"

Run BASIC

print "Goodbye, World!"

Rust

Works with: rustc version 0.12.0-pre

 
fn main () {
   println!("Goodbye, World!");
}
 

Salmon

"Goodbye, World!"!

or

print("Goodbye, World!\n");

or

standard_output.print("Goodbye, World!\n");

SAS

/* Using a data step. Will print the string in the log window */
data _null_;
put "Goodbye, World!";
run;

Sather

class GOODBYE_WORLD is
 main is 
  #OUT+"Goodbye, World!\n"; 
 end; 
end;

Scala

Library: Console

Ad hoc REPL solution

Ad hoc solution as REPL script. Type this in a REPL session:

println("Goodbye, World!")

Via Java runtime

This is a call to the Java run-time library. Not recommendated.

System.out.println("Goodbye, World!")

Via Scala Console API

This is a call to the Scala run-time library. Recommendated.

println("Goodbye, World!")

Short term deviation to out

Console.withErr(Console.out) { Console.err.println("This goes to default _out_") }

Long term deviation to out

  Console.err.println ("Err not deviated")
  Console.setErr(Console.out)
  Console.err.println ("Err deviated")
  Console.setErr(Console.err) // Reset to normal

Scheme

Works with: Gauche

Works with: Guile

(display "Goodbye, World!")
(newline)

Works with: Gauche

(print "Goodbye, World!")

or just:

"Goodbye, World!"

(should work on any scheme)

R7RS Scheme

(import (scheme base)
        (scheme write))
(display "Hello, world!")
(newline)

Scilab

disp("Goodbye, World!");

sed

i\
Goodbye, World!
q

Seed7

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

Self

'Goodbye, World!' printLine.

Shiny

say 'Goodbye, World!'

Sidef

„Goodbye, World!”.say;

SIMPOL

function main()
end function "Goodbye, World!{d}{a}"

Simula

Works with: SIMULA-67

BEGIN
   OUTTEXT("Goodbye, World!");
   OUTIMAGE
END

Sisal

define main
 
% Sisal doesn't yet have a string built-in.
% Let's define one as an array of characters.
 
type string = array[character];
 
function main(returns string)
  "Goodbye, World!"
end function

Slate

inform: 'Goodbye, World!'.

Smalltalk

Transcript show: 'Goodbye, World!'; cr.

Works with: GNU Smalltalk

(as does the above code)

'Goodbye, World!' printNl.

SNOBOL4

Using CSnobol4 dialect

    OUTPUT = "Goodbye, World!"
END

SNUSP

Core SNUSP

/++++!/===========?\>++.>+.+++++++..+++\
\+++\ | /+>+++++++>/ /++++++++++<<.++>./
$+++/ | \+++++++++>\ \+++++.>.+++.-----\
      \==-<<<<+>+++/ /=.>.+>.--------.-/

Modular SNUSP

@\G.@\o.o.@\d.--b.@\y.@\e.>@\comma.@\.<-@\W.+@\o.+++r.------l.@\d.>+.! #
 |   |     \@------|#  |    \@@+@@++|+++#-    \\               -
 |   \@@@@=+++++#  |   \===--------!\===!\-----|-------#-------/
 \@@+@@@+++++#     \!#+++++++++++++++++++++++#!/

SoneKing Assembly

 
extern print
 
dv Msg Goodbye,World!
 
mov eax Msg
push
call print
pop
 

Sparkling

print("Goodbye, World!");

SPARC Assembly

 
	.section	".text"
	.global		_start
_start:
	mov	4,%g1			! 4 is SYS_write
	mov	1,%o0			! 1 is stdout
	set	.msg,%o1		! pointer to buffer
	mov	(.msgend-.msg),%o2	! length
	ta	8
 
	mov	1,%g1			! 1 is SYS_exit
	clr	%o0			! return status is 0
	ta	8
 
.msg:
	.ascii	"Goodbye, world!\n"
.msgend:
 

Standard ML

print "Goodbye, World!\n"

Suneido

Print("Goodbye, World!")

Swift

println("Goodbye, World!")

Teco

Outputting to terminal. Please note that ^A means control-A, not a caret followed by 'A', and that $ represent the ESC key.

^AGoodbye, World!^A$$

Tcl

Output to terminal:

puts "Goodbye, World!"

Output to arbitrary open, writable file:

puts $fileID "Goodbye, World!"

TestML

%TestML 0.1.0
Print("Goodbye, World!")

TI-83 BASIC

See TI-89 BASIC.

TI-89 BASIC

Disp "Goodbye, World!"

TorqueScript

echo("Goodbye, World!");

Transact-SQL

PRINT "Goodbye, World!"

Trith

"Goodbye, World!" print

TPP

Goodbye, World!

TUSCRIPT

 
$$ MODE TUSCRIPT
PRINT "Goodbye, World!"
 

Output:

Goodbye, World!

Uniface

 
message "Goodbye, World!"
 

UNIX Shell

Works with: Bourne Shell

#!/bin/sh
echo "Goodbye, World!"

C Shell

#!/bin/csh -f
echo "Goodbye, World\!"

We use \! to prevent history substitution. Plain ! at end of string seems to be safe, but we use \! to be sure.

Unlambda

`r```````````````.G.o.o.d.b.y.e.,. .W.o.r.l.d.!i

Uniface

 
message "Goodbye, World!"
 

Ursala

output as a side effect of compilation

#show+
 
main = -[Goodbye, World!]-

output by a compiled executable

#import std
 
#executable ('parameterized','')
 
main = <file[contents: -[Goodbye, World!]-]>!

உயிர்/Uyir

முதன்மை என்பதின் வகை பணி {{
       {"உலகத்தோருக்கு வணக்கம்"} என்பதை திரையீடு;
}};

V

"Goodbye, World!" puts

Vala

void main(){
	stdout.printf("Goodbye, World!\n");
}

VBScript

Works with: Windows Script Host version 5.7

WScript.Echo("Goodbye, World!")

Vedit macro language

Message("Goodbye, World!")

VHDL

LIBRARY std;
USE std.TEXTIO.all;
 
entity test is
end entity test;
 
architecture beh of test is
begin
  process
    variable line_out : line;
  begin
    write(line_out, string'("Goodbye, World!"));
    writeline(OUTPUT, line_out);
    wait; -- needed to stop the execution
  end process;
end architecture beh;

Vim Script

echo "Goodbye, World!\n"

Wart

prn "Goodbye, World!"

Whenever

1 print("Goodbye, World!");

Whiley

import whiley.lang.System
 
method main(System.Console console):
    console.out.println("Goodbye, World!")

Whitespace

There is a "Hello World" - example-program on the Whitespace-website

Wolfram Language

Print["Goodbye, World!"]

Wren

IO.print("Goodbye, World!")

X86 Assembly

Works with: nasm version 2.05.01

This is known to work on Linux, it may or may not work on other Unix-like systems

Prints "Goodbye, World!" to stdout (and there is probably an even simpler version):

section .data
msg     db      'Goodbye, World!', 0AH
len     equ     $-msg
 
section .text
global  _start
_start: mov     edx, len
        mov     ecx, msg
        mov     ebx, 1
        mov     eax, 4
        int     80h
 
        mov     ebx, 0
        mov     eax, 1
        int     80h

XL

use XL.UI.CONSOLE
WriteLn "Goodbye, World!"

XPL0

code Text=12;
Text(0, "Goodbye, World!
")

XSLT

<xsl:text>Goodbye, World!
</xsl:text>

Yorick

write, "Goodbye, World!"

Z80 Assembly

Using the Amstrad CPC firmware:

org		$4000
 
txt_output:	equ	$bb5a
 
		push	hl
		ld	hl,world
 
print:		ld	a,(hl)
		cp	0
		jr	z,end
		call	txt_output
		inc	hl
		jr	print
 
end:		pop	hl
		ret
 
world:		defm	"Goodbye, World!\r\n\0"

zkl

println("Goodbye, World!");