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 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 main () = 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!"

BASIC256

PRINT "Goodbye, World!"

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

print Goodbye, World!

Boo

print "Goodbye, World!"

Brace

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

Brainf***

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

C#

Works with: Mono version 1.2

Works with: Visual C# version 2003

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

C++

#include <iostream>
 
int main () {
  std::cout << "Goodbye, World!" << std::endl;
  return std::cout.bad();
}

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

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
 

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

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: .NET version 3.5

Works with: .NET version 4.0

One Line version:

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

Hello World Program:

 
//compile using the new dylan.NET v, 11.2.8.2 or later
//use mono to run the compiler
#refstdasm mscorlib.dll
 
import System
 
assembly helloworld exe
ver 1.2.0.0
 
class public auto ansi Module1
 
   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

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

Elisa

 "Goodbye, World!"? 

Emacs Lisp

(insert "Goodbye, World!")

Erlang

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

Euphoria

puts(1,"Goodbye, World!\n")

EGL

Works with: EDT

Works with: RBD

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

Euler Math Toolbox

"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

> "Goodbye, World!"

FALSE

"Goodbye, World!
"

Fantom

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

ferite

word.}}

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

Fexl

print "Goodbye, World!";nl;

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

Gambas

 
PRINT "Goodbye, World!"
 

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.

GLBasic

STDOUT "GOODBYE, WORLD!"

Glee

"Goodbye, World!"

Go

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

Golfscript

"Goodbye, World!"

Gosu

print("Goodbye, World!")

Groovy

println "Goodbye, World!"

GW-BASIC

10 PRINT "Goodbye, World!"

Harbour

? "Goodbye, World!"

Haskell

main = putStrLn "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.

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;

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

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

Nimrod

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

Onyx

`Goodbye, World!\n' print

OOC

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

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

put ('Goodbye, World!');

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

Run BASIC

print "Goodbye, World!"

Rust

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)

Scilab

disp("Goodbye, World!");

sed

cGoodbye, World!

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

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

Standard ML

print "Goodbye, World!\n"

Suneido

Print("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!

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

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

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;

Wart

prn "Goodbye, World!"

Whenever

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