Hello world/Standard error

A common practice in computing is to send error messages to a different output stream than normal text console messages.

Task
Hello world/Standard error
You are encouraged to solve this task according to the task description, using any language you may know.
Hello world/Standard error is part of Short Circuit's Console Program Basics selection.

The normal messages print to what is called "standard output" or "standard out".

The error messages print to "standard error".

This separation can be used to redirect error messages to a different place than normal messages.


Task

Show how to print a message to standard error by printing     Goodbye, World!     on that stream.

11l

Translation of: Python
:stderr.write("Goodbye, World!\n")

4DOS Batch

echoerr Goodbye, World!

AArch64 Assembly

.equ STDERR, 2
.equ SVC_WRITE, 64
.equ SVC_EXIT, 93

.text
.global _start

_start:
	stp x29, x30, [sp, -16]!
	mov x0, #STDERR
	ldr x1, =msg
	mov x2, 15
	mov x8, #SVC_WRITE
	mov x29, sp
	svc #0 // write(stderr, msg, 15);
	ldp x29, x30, [sp], 16
	mov x0, #0
	mov x8, #SVC_EXIT
	svc #0 // exit(0);

msg:	.ascii "Goodbye World!\n"

Ada

with Ada.Text_IO;  use Ada.Text_IO;

procedure Goodbye_World is
begin
   Put_Line (Standard_Error, "Goodbye, World!");
end Goodbye_World;

Agena

io.write( io.stderr, "Goodbye, World!\n" )

Aime

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

ALGOL 68

The procedures print and printf output to stand out, whereas put and putf can output to any open file, including stand error.

Works with: ALGOL 68 version Revision 1 - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d - note that printf and putf were not ported into ELLA's libraries.
main:(
  put(stand error, ("Goodbye, World!", new line))
)
Output:
Goodbye, World!

Argile

use std
eprint "Goodbye, World!"

or

use std
eprintf "Goodbye, World!\n"

or

use std
fprintf stderr "Goodbye, World!\n"

ARM Assembly

Works with: as version Raspberry Pi
/* ARM assembly Raspberry PI  */
/*  program hellowordLP.s   */
.data
szMessage: .asciz "Goodbye world. \n "       @ error message
.equ LGMESSAGE, . -  szMessage  @ compute length of message

.text
.global main 
main:	
    mov r0, #2                  @ output error linux
    ldr r1, iAdrMessage         @ adresse of message
    mov r2, #LGMESSAGE          @ sizeof(message) 
    mov r7, #4                  @ select system call 'write' 
    swi #0                      @ perform the system call 
 
    mov r0, #0                  @ return code
    mov r7, #1                  @ request to exit program
    swi #0                       @ perform the system call
iAdrMessage: .int szMessage

Arturo

panic "Goodbye, World!"

ATS

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

AutoHotkey

requires AutoHotkey_N implementation.

; c:\>  autohotkey.exe stderr.ahk 2> error.txt
FileAppend, Goodbye`, World!, stderr   ; requires AutoHotkey_N

Or with the current AutoHotkey_L:

Works with: AutoHotkey_L

(documentation on this behavior: http://www.autohotkey.net/~Lexikos/AutoHotkey_L/docs/commands/FileAppend.htm)

FileAppend, Goodbye`, World!, *

AutoIt

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

Avail

Error: "Goodbye, World!";

AWK

To print a message to standard error, pipe it through a shell command:

BEGIN {
  print "Goodbye, World!"| "cat 1>&2"
}

Or write to /dev/stderr:

Works with: gawk
Works with: mawk
Works with: nawk
BEGIN {
  print "Goodbye, World!" > "/dev/stderr"
}

With gawk, mawk and nawk: a special feature associates "/dev/stderr" with standard error. The manuals of gawk and mawk describe this feature; nawk also has this feature.

Other implementations might try to open /dev/stderr as a file. Some Unix clones, like BSD, have a /dev/stderr device node that duplicates standard error, so this code would still work. Some systems have no such device node, so this code would fail. We recommend "cat 1>&2", which is more portable, and works with any Unix clone.

BASIC

Applesoft BASIC

REM FILE-BASED OUTPUT REDIRECTION
 0 D$ =  CHR$ (4):F$ = "DEV/STDERR": PRINT D$"OPEN"F$: PRINT D$"CLOSE"F$: PRINT D$"APPEND"F$: PRINT D$"WRITE"F$
 1  PRINT "GOODBYE, WORLD!"
 2  PRINT D$"CLOSE"F$
REM OUTPUT ROUTINE REDIRECTION
 3  FOR I = 768 TO 802: READ B: POKE I,B: NEXT : POKE 54,0: POKE 55,3: CALL 1002: DATA 72,173,34,3,208,8,169,191,141,34,3,32,240,253,104,201,141,208,12,169,0,141,34,3,169,135,32,240,253,169,141,76,240,253,0
 4 O$ =  CHR$ (111):D$ =  CHR$ (100): PRINT "G" + O$ + O$ + D$ +  CHR$ (98) +  CHR$ (121) +  CHR$ (101) + ", W" + O$ +  CHR$ (114) +  CHR$ (108) + D$ + "!"
 5  POKE 54,240: POKE 55,253: CALL 1002

BaCon

EPRINT "Goodbye, World!"

BASIC256

onerror errortrap
throwerror 99
end

errortrap:
print "Goodbye World!"
return

Chipmunk Basic

Works with: Chipmunk Basic version 3.6.4
10 cls
20 on error goto 50
30 error 99 : we force an error
40 end
50 rem ManejoErrores
60 print "Goodbye World!"
70 cont

QBasic

ON ERROR GOTO ManejoErrores
ERROR 99
END

ManejoErrores:
  PRINT "Googbye World!"
  RESUME

ZX Spectrum Basic

On the ZX Spectrum, standard error is on stream 1:

10 PRINT #1;"Goodbye, World!"
20 PAUSE 50: REM allow time for the user to see the error message

Batch File

1>&2 echo Goodbye, World!

The redirection operator 1>&2 causes all output on stream 1 (standard out) to be redirected to stream 2 (standard error). The redirection can be moved to the end of the line, too.

BBC BASIC

The program must be compiled as a console application for this to work.

      STD_ERROR_HANDLE = -12
      SYS "GetStdHandle", STD_ERROR_HANDLE TO @hfile%(1)
      PRINT #13, "Goodbye, World!"
      QUIT

Blade

import io
io.stderr.write('Goodbye, World!')

C

Unlike puts(), fputs() does not append a terminal newline.

#include <stdio.h>

int main()
{
	fprintf(stderr, "Goodbye, ");
	fputs("World!\n", stderr);

	return 0;
}

C#

static class StdErr
{
    static void Main(string[] args)
    {
        Console.Error.WriteLine("Goodbye, World!");
    }
}

C++

#include <iostream>

int main() {
  std::cerr << "Goodbye, World!\n";
}

Clojure

(binding [*out* *err*]
  (println "Goodbye, world!"))

CLU

start_up = proc ()
    stream$putl(stream$error_output(), "Goodbye, World!")
end start_up

CMake

Most messages go to standard error.

message("Goodbye, World!")

The message cannot be a keyword; message("STATUS") never prints "STATUS", but message("" "STATUS") does work.

COBOL

Using fixed format.

Works with: OpenCOBOL
	program-id. ehello.
	procedure division.
		display "Goodbye, world!"  upon syserr.
		stop run.

CoffeeScript

Translation of: JavaScript
Works with: Node.js
console.warn "Goodbye, World!"

Common Lisp

(format *error-output* "Goodbye, world!~%")

D

import std.stdio;

void main () {
    stderr.writeln("Goodbye, World!");
}

Alternative Version

Library: tango
import tango.io.Stdout;

void main () {
    Stderr("Goodbye, World!").newline;
}

Dart

import 'dart:io';

void main() {
  stderr.writeln('Goodbye, World!');
}

Delphi

program Project1;

{$APPTYPE CONSOLE}

begin
  WriteLn(ErrOutput, 'Goodbye, World!');
end.

dt

"Goodbye, World!" epl

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::get_Error()::WriteLine("Goodbye World!")

Goodbye 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 stderrex exe
ver 1.1.0.0

class public Program

   method public static void main()
      Console::get_Error()::WriteLine("Goodbye World!")
   end method

end class

Déjà Vu

!write-fragment!stderr !encode!utf-8 "Goodbye, World!\n"

E

stderr.println("Goodbye, World!")

Elixir

IO.puts :stderr, "Goodbye, World!"

Emacs Lisp

In batch mode, message actually prints to standard error:

(message "Goodbye, World!")

For greater control, princ can be used with a special printing function:

(princ "Goodbye, World!\n" 'external-debugging-output)

EMal

logLine("Goodbye, World!")
log("Goodbye, World!")

Erlang

io:put_chars(standard_error, "Goodbye, World!\n").

Euphoria

puts(2,"Goodbye, world!\n") -- 2 means output to 'standard error'

F#

eprintfn "%s" "Goodbye, World!"

or you can use the .Net classes

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

Factor

Start Factor in a terminal for this:

error-stream get [ "Goodbye, World! bbl, crashing" print flush ] with-output-stream*

Fantom

class Main
{
  public static Void main ()
  {
    Env.cur.err.printLine ("Goodbye, World!")
  }
}

Forth

Works with: GNU Forth
outfile-id
  stderr to outfile-id
  ." Goodbye, World!" cr
to outfile-id

Fortran

Normally standard error is associated with the unit 0 but this could be different for different vendors. Therefore since Fortran 2003 there's an intrinsic module which defines the parameter ERROR_UNIT.

program StdErr
  ! Fortran 2003
  use iso_fortran_env

  ! in case there's no module iso_fortran_env ...
  !integer, parameter :: ERROR_UNIT = 0
  
  write (ERROR_UNIT, *) "Goodbye, World!"
end program StdErr

FreeBASIC

' FB 1.05.0 Win64

Open Err As #1
Print #1, "Goodbye World!"
Close #1
Sleep

Frink

staticJava["java.lang.System","err"].println["Goodbye, World!"]

Genie

[indent=4]
/*
  Hello, to Standard error, in Genie
  valac helloStderr.gs
*/

init
    stderr.printf("%s\n", "Goodbye, World!")
Output:
prompt$ ./helloStderr | wc
Goodbye, World!
      0       0       0

Go

Built in println now goes to stderr.

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

but the builtin print() and println() functions are not guaranteed to stay in the language. So you should probably use

package main
import ("fmt"; "os")
func main() { fmt.Fprintln(os.Stderr, "Goodbye, World!") }

Groovy

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

Haskell

import System.IO
main = hPutStrLn stderr "Goodbye, World!"

Huginn

#! /bin/sh
exec huginn --no-argv -E "${0}" "${@}"
#! huginn

import OperatingSystem as os;

main() {
	os.stderr().write( "Goodbye, World!\n" );
	return ( 0 );
}

Icon and Unicon

procedure main()
  write(&errout, "Goodbye World" )
end

J

   stderr
1!:2&5

   0 0 $ stderr 'Goodbye, World!'

Java

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

JavaScript

Works with: JScript
and only with cscript.exe
WScript.StdErr.WriteLine("Goodbye, World!");
Works with: Node.js
console.warn("Goodbye, World!")
Works with: Firefox
console.error("Goodbye, World!")//only works if console object exists

OR

throw new Error("Goodbye, World!")//Should work in any browser

Joy

stderr "Goodbye, World!\n" fputchars pop.

jq

jq -n —-arg s 'Goodbye, World!' '$s | stderr | empty'

`stderr` copies its input to STDERR before passing it along the pipeline, and hence the occurrence of `empty` above.

Julia

println(STDERR, "Goodbye, World!")

Kotlin

fun main(args: Array<String>) {
    System.err.println("Goodbye, World!")
}

Lang

fn.errorln(Goodbye, World!)

langur

writelnErr "goodbye, people"

Lasso

define stderr(s::string) => {
    file_stderr->writeBytes(#s->asBytes)
}

stderr('Goodbye, World!')

Lingo

  • Windows:
-- print to standard error
stdErr("Goodbye, World!", TRUE)

-- print to the Windows debug console (shown in realtime e.g. in Systernal's DebugView)
dbgPrint("Goodbye, World!")
  • Mac OS X:
Library: Shell Xtra
sx = xtra("Shell").new()

-- print to standard error
sx.shell_cmd("echo Goodbye, World!>&2")

-- print to system.log (shown in realtime e.g. in Konsole.app)
sx.shell_cmd("logger Goodbye, World!")

Lean

In lean4

def main : IO Unit := do
  let stderr ← IO.getStderr
  stderr.putStrLn s!"Goodbye, World!"

LLVM

; This is not strictly LLVM, as it uses the C library function "printf".
; LLVM does not provide a way to print values, so the alternative would be
; to just load the string into memory, and that would be boring.

; Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps

%struct._iobuf = type { i8* }

$"message" = comdat any
@"message" = linkonce_odr unnamed_addr constant [17 x i8] c"Goodbye, world!\0A\00", comdat, align 1

;-- For discovering stderr (io pipe 2)
declare %struct._iobuf* @__acrt_iob_func(i32)

;--- The declaration for the external C fprintf function.
declare i32 @fprintf(%struct._iobuf*, i8*, ...)

define i32 @main() {
;-- load stderr
  %1 = call %struct._iobuf* @__acrt_iob_func(i32 2)
;-- print the message to stderr with fprintf
  %2 = call i32 (%struct._iobuf*, i8*, ...) @fprintf(%struct._iobuf* %1, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @"message", i32 0, i32 0))
;-- exit
  ret i32 0
}
Output:
Goodbye, world!

Logtalk

The stream alias "user_error" can be used to print to the "standard error" stream.

:- object(error_message).

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

:- end_object.

Lua

io.stderr:write("Goodbye, World!\n")

m4

errprint(`Goodbye, World!
')dnl

MANOOL

{{extern "manool.org.18/std/0.3/all"} in Err.WriteLine["Goodbye, World!"]}

Maple

error "Goodbye World"

Mathematica / Wolfram Language

Write[Streams["stderr"], "Goodbye, World!"]

MATLAB / Octave

This prints to standard error, and continues execution

fprintf(2,'Goodbye, World!')

This will not stop further execution, if called from within a script or function.

error 'Goodbye, World!'

Mercury

:- module hello_error.
:- interface.

:- import_module io.
:- pred main(io::di, io::uo) is det.

:- implementation.

main(!IO) :-
    io.stderr_stream(Stderr, !IO),
    io.write_string(Stderr, "Goodbye, World!\n", !IO).

Metafont

Metafont has no a real way to send a text to the standard output/error nor to a file. Anyway it exists the errmessage command which will output an error message and prompt the user for action (suspending the interpretation of the source).

errmessage "Error";
message "...going on..."; % if the user decides to go on and not to stop
                          % the program because of the error.

min

Works with: min version 0.37.0

Currently, min has three possibilities for outputting to stderr:

"Goodbye, World!" warn!
"Goodbye, World!" error!
"Goodbye, World!" fatal!

The first two depend on the current log level (and are enabled by default). The last one additionally terminates the program.

ML/I

MCSET S4=1
MCNOTE Goodbye, World!

Miranda

main :: [sys_message]
main = [Stderr "Hello, world!\n"]

Modula-2

MODULE HelloErr;
IMPORT StdError;

BEGIN
  StdError.WriteString('Goodbye, World!');
  StdError.WriteLn
END HelloErr.

Modula-3

MODULE Stderr EXPORTS Main;

IMPORT Wr, Stdio;

BEGIN
  Wr.PutText(Stdio.stderr, "Goodbye, World!\n");
END Stderr.

N/t/roff

The request .tm prints whatever after it, until and including the newline character, to the standard error. The string parsed to it need not be quoted and will never appear on standard output.

.tm Goodbye, World!

Neko

/**
  Hello world, to standard error, in Neko
  Tectonics:
    nekoc hello-stderr.neko
    neko hello-stderr
*/

/* Assume stderr is already open, just need write */
var file_write = $loader.loadprim("std@file_write", 4);

/* Load (and execute) the file_stderr primitive */
var stderr = $loader.loadprim("std@file_stderr", 0)();

file_write(stderr, "Goodbye, World!\n", 0, 16);
Output:
prompt$ nekoc hello-stderr.neko
prompt$ neko hello-stderr
Goodbye, World!
prompt$ neko hello-stderr 2>/dev/null
prompt$

Nemerle

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

NetRexx

/* NetRexx */

options replace format comments java crossref savelog symbols binary

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

Nim

stderr.writeLine "Hello World"

Nu

print -e "Goodbye, World!"

Oberon-2

Oxford Oberon-2

MODULE HelloErr;
IMPORT Err;
BEGIN
	Err.String("Goodbye, World!");Err.Ln
END HelloErr.
Output:
Goodbye, World!

Objective-C

Works with: GNUstep
Works with: Cocoa

In Objective-C one can use the standard C library and the stderr as in the C language; nonetheless a common way to output to stderr for logging purpose and/or error notification is the NSLog function, that works almost like fprintf(stderr, "..."), save for the fact that the format string is an NSString object, and it also prepends a timestamp.

#import <Foundation/Foundation.h>

int main()
{
   fprintf(stderr, "Goodbye, World!\n");
   fputs("Goodbye, World!\n", stderr);
   NSLog(@"Goodbye, World!");
   return 0;
}

OCaml

prerr_endline "Goodbye, World!";    (* this is how you print a string with newline to stderr *)
Printf.eprintf "Goodbye, World!\n"; (* this is how you would use printf with stderr *)

we can also use the out_channel stderr:

output_string stderr "Goodbye, World!\n";
Printf.fprintf stderr "Goodbye, World!\n";

finally the Unix module also provides unbuffered write functions:

let msg = "Goodbye, World!\n" in
ignore(Unix.write Unix.stderr msg 0 (String.length msg)) ;;

Octave

fprintf(stderr, "Goodbye, World!\n");

Oforth

System.Err "Goodbye, World!" << cr

Ol

(print-to stderr "Goodbye, World!")

ooRexx

ooRexx provides a .error object that writes output to the standard error stream.

.error~lineout("Goodbye, World!")

The .error object is a proxy that delegates to a backing stream, so this might be redirected. By default, this delegates to the .stderr object, which can also be used directly.

.stderr~lineout("Goodbye, World!")

or in 'Classic REXX style'

/* REXX ---------------------------------------------------------------
* 07.07.2014 Walter Pachl
* 12.07.2014 WP see Discussion where redirection from within the program is shown
*--------------------------------------------------------------------*/
Say 'rexx serr 2>err.txt directs the stderr output to the file err.txt'
Call lineout 'stderr','Good bye, world!'
Call lineout ,'Hello, world!'
Say 'and this is the error output:'
'type err.txt'

Oz

functor
import Application System
define
   {System.showError "Goodbye, World!"}
   {Application.exit 0}
end

PARI/GP

error("Goodbye, World!")

Pascal

Works with: Free Pascal
program byeworld;
 
begin
  writeln(StdErr, 'Goodbye, World!');
end.

Perl

warn "Goodbye, World!\n";

Or:

print STDERR "Goodbye, World!\n";

Phix

puts(2,"Goodbye, World!")

PHP

fprintf(STDERR, "Goodbye, World!\n");

or

file_put_contents("php://stderr","Hello World!\n");

Picat

println(stderr,"Goodbye, World!")

PicoLisp

(out 2 (prinl "Goodbye, World!"))

Pike

werror("Goodbye, World!");

PL/I

display ('Goodbye, World');

PostScript

(%stderr) (w) file dup
(Goodbye, World!
) writestring
closefile

PowerBASIC

STDERR "Goodbye, World!"

PowerShell

Since PowerShell has a slightly different system of pipes and streams (to facilitate easy usage from a host application) the standard Write-Error cmdlet is mainly for sending annotated error messages to the host:

Write-Error "Goodbye, World!"

Note that this outputs more than just the message, because behind the scenes it is an uncaught exception:

Write-Error "Goodbye, World!" : Goodbye, World!
    + CategoryInfo          : NotSpecified: (:) [Write-Error], WriteErrorException
    + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException

To accurately reproduce the behavior of other languages one has to resort to .NET in this case:

[Console]::Error.WriteLine("Goodbye, World!")

PureBasic

ConsoleError() writes the message string (plus a newline) to the standard error output of current program.

Standard error output can be used in conjunction with ReadProgramError() to reads a line from an other programs error output (stderr).

ConsoleError("Goodbye, World!")

Python

Works with: Python version 2.x
import sys

print >> sys.stderr, "Goodbye, World!"
Works with: Python version 3.x
import sys

print("Goodbye, World!", file=sys.stderr)

Works with either:

import sys

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

R

cat("Goodbye, World!", file=stderr())

Ra

class HelloWorld
	**Prints "Goodbye, World!" to standard error**

	on start

		print to Console.error made !, "Goodbye, World!"

Racket

(eprintf "Goodbye, World!\n")

Raku

(formerly Perl 6)

note "Goodbye, World!";

Retro

'Goodbye,_World! '/dev/stderr file:spew

REXX

version 1

This version will work with those operating systems (hosts) that support stream output and a STDERR output
stream (by name).
If the   stderr   name is supported and enabled, the output is written to the terminal.
If not supported or disabled, the output is written to a (disk) file named   STDERR.

call lineout 'STDERR', "Goodbye, World!"

version 2

Same as above, but uses a different style and also invokes   charout   instead of   lineout.

msgText = 'Goodbye, World!'
call charout 'STDERR', msgText

version 3

This works on Windows 7 and ooRexx and REGINA

/* REXX ---------------------------------------------------------------
* 07.07.2014 Walter Pachl
* enter the appropriate command shown in a command prompt.
*    "rexx serr.rex 2>err.txt"
* or "regina serr.rex 2>err.txt" 
* 2>file will redirect the stderr stream to the specified file. 
* I don't know any other way to catch this stream
*--------------------------------------------------------------------*/
Parse Version v
Say v
Call lineout 'stderr','Good bye, world!'
Call lineout ,'Hello, world!'
Say 'and this is the error output:'
'type err.txt'

version 4

ARexx with tracing console

/**/
Address command tco
Call writeln stderr,'Good bye, world!'
Call writeln stdout,'Hello, world!'

Ring

fputs(stderr,"Goodbye, World!")

RPL

There is no error console in RPL but all error messages are displayed at the top two lines of the display, which freezes until a key is pressed. This can be mimicked with the DISP instruction:

≪ "Hello world!" 1 DISP ≫

Ruby

STDERR.puts "Goodbye, World!"

The following also works, unless you have disabled warnings (ruby command line option "-W0" or set $VERBOSE=nil)

warn "Goodbye, World!"

Run BASIC

html "<script>
window.open('','error_msg','');
document.write('Goodbye, World!');
</script>""

Run Basic runs in a browser. This opens a new browser window, or a tab in the case of Chrome and some others.

Rust

fn main() {
    eprintln!("Hello, {}!", "world");
}

or

fn main() {
    use ::std::io::Write;
    let (stderr, errmsg) = (&mut ::std::io::stderr(), "Error writing to stderr");
    writeln!(stderr, "Bye, world!").expect(errmsg);
    
    let (goodbye, world) = ("Goodbye", "world");
    writeln!(stderr, "{}, {}!", goodbye, world).expect(errmsg);
}

or

fn main() {
    use std::io::{self, Write};

    io::stderr().write(b"Goodbye, world!").expect("Could not write to stderr");
    // With some finagling, you can do a formatted string here as well
    let goodbye = "Goodbye";
    let world = "world";
    io::stderr().write(&*format!("{}, {}!", goodbye, world).as_bytes()).expect("Could not write to stderr");
    // Clearly, if you want formatted strings there's no reason not to just use writeln!
}

S-lang

() = fputs("Goodbye, World!\n", stderr);

Salmon

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

or

include "short.salm";
stderr.print("Goodbye, World!\n");

or

include "shorter.salm";
err.print("Goodbye, World!\n");

or

include "shorter.salm";
se.print("Goodbye, World!\n");

Sather

class MAIN is
  main is
    #ERR + "Hello World!\n";
  end;
end;

Scala

Library: Console

Ad hoc REPL solution

Ad hoc solution as REPL script:

Console.err.println("Goodbye, World!")

Via Java runtime

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

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

Via Scala Console API

This is a call to the Scala API. Recommendated.

Console.err.println("Goodbye, World!")

Short term deviation to err

Console.withOut(Console.err) { println("This goes to default _err_") }

Long term deviation to err

  println ("Out not deviated")
  Console.setOut(Console.err)
  println ("Out deviated")
  Console.setOut(Console.out) // Reset to normal

Scheme

(error "Goodbye, World!")

Scilab

error("Goodbye, World!")

sed

Requires /dev/stderr

#n
1 {
	s/.*/Goodbye, World!/w /dev/stderr
}

This program requires at least 1 line of input. It changes the first line to "Goodbye, World!" and then prints the first line to standard error. It reads and ignores the remaining lines.

Test output:
$ echo a | sed -f error.sed >/dev/null
Goodbye, World!

Seed7

$ include "seed7_05.s7i";

const proc: main is func
  begin
    writeln(STD_ERR, "Goodbye, World!");
  end func;

Sidef

STDERR.println("Goodbye, World!");

Slate

inform: 'Goodbye, World!' &target: DebugConsole.

Slope

(write "Goodbye, world!" stderr)

Smalltalk

The details on to which name stderr is bound may vary between Smalltalk dialects. If different, a "Smalltalk at:#Stderr put:<name your stream here>" should provide compatibility.

Stderr nextPutAll: 'Goodbye, World!'

However, all Smalltalks provide a console named "Transcript", where diagnostics is usually sent to (which is convenient, if there is no stderr to look at, as when started in Windows as an exe, vs. a com).
Thus:

Transcript show: 'Goodbye, World!'

will work on all, and is the preferred way to do this.
(and yes, when running UI-less as a console program, the global "Transcript" is usually bound to the stderr stream).

The above tells the stream to write a string; you can also tell the string to print itself onto some stream:

'Goodbye, World!' printOn: Stderr

Both have the same effect.

SNOBOL4

        terminal = "Error"
        output = "Normal text"
end

Standard ML

TextIO.output (TextIO.stdErr, "Goodbye, World!\n")

Swift

import Foundation

let out = NSOutputStream(toFileAtPath: "/dev/stderr", append: true)
let err = "Goodbye, World!".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)
out?.open()
let success = out?.write(UnsafePointer<UInt8>(err!.bytes), maxLength: err!.length)
out?.close()

if let bytes = success {
    println("\nWrote \(bytes) bytes")
}
Output:
Goodbye, World!
Wrote 15 bytes

Tcl

puts stderr "Goodbye, World!"

Transact-SQL

 RAISERROR 'Goodbye, World!', 16, 1

True BASIC

CAUSE error 1, "Goodbye World!"
END

TUSCRIPT

$$ MODE TUSCRIPT
PRINT/ERROR "hello world"
text="goodbye world"
PRINT/ERROR text
Output:
@@@@@@@@  hello world                                                  @@@@@@@@
@@@@@@@@  goodbye world                                                @@@@@@@@

UNIX Shell

Works with: Bourne Shell
echo "Goodbye, World!" >&2

C Shell

echo "Goodbye, World!" >/dev/stderr

This requires /dev/stderr, a device node from BSD and some other Unix clones. This command works with both Bourne Shell and C Shell.

Ursa

out "goodbye, world!" endl console.err

VBA

Sub StandardError()
    Debug.Print "Goodbye World!"
End Sub

VBScript

Must work in cscript.exe

WScript.StdErr.WriteLine "Goodbye, World!"

Verbexx

@STDERR "Goodbye, World!\n";

Visual Basic .NET

Module Module1

    Sub Main()
        Console.Error.WriteLine("Goodbye, World!")
    End Sub

End Module

WDTE

io.writeln io.stderr 'Goodbye, World!';

Wren

Fiber.abort("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

Note that it is only 2 characters different from the Assembly example on User Output - text

Prints "Goodbye, World!" to stderr (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, 2
        mov     eax, 4
        int     80h

        mov     ebx, 1
        mov     eax, 1
        int     80h

XLISP

(DISPLAY "Goodbye, World!" *ERROR-OUTPUT*)

XPL0

The terms "standard output" and "standard error" are not used, but it's trivial to send messages to a variety of devices by specifying their numbers. Normally messages are displayed on the text console, which is device 0. Instead, this example sends the message to the (first) printer, which is device 2.

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


Yabasic

error "Goodbye World!"


Zig

Works with: 0.10.x, 0.11.x, 0.12.0-dev.1357+10d03acdb

Variant with error handling:

const std = @import("std");

pub fn main() std.fs.File.WriteError!void {
    const stderr = std.io.getStdErr();

    try stderr.writeAll("Goodbye, World!\n");
}

Works with: 0.10.x, 0.11.x, 0.12.0-dev.1357+10d03acdb

Variant with no error handling (useful when debugging):

const std = @import("std");

pub fn main() void {
    // Silently returns if writing to stderr fails.
    std.debug.print("Goodbye, World!\n", .{});
}

zkl

File.stderr.writeln("Goodbye, World!")