Hello world/Text

From Rosetta Code
Task
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.
Task

Display the string Hello world! on a text console.

Related tasks



0815

<:48:x<:65:=<:6C:$=$=$$~<:03:+
$~<:ffffffffffffffb1:+$<:77:~$
~<:fffffffffffff8:x+$~<:03:+$~
<:06:x-$x<:0e:x-$=x<:43:x-$

11l

print(‘Hello world!’)

360 Assembly

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

HELLO    CSECT 
         USING HELLO,15
         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'Hello world!'  Text to be written to system console
         END

Using WTO Macro to generate SVC 35 and message area:

         WTO   'Hello world!'
         BR    14            Return
         END

IBM Z HL/ASM

Using Modern IBM Z High Level assembler to write 'Hello World' to the Unix System Services 'stdout' file descriptor

        PRINT ON,GEN,DATA
HELLO   CSECT
HELLO   RMODE ANY
HELLO   AMODE 31
*
* Prolog
*
        SAVE (14,12)
        BASR R12,0
        USING *,R12
        STORAGE OBTAIN,LENGTH=DYNL,ADDR=(R11)
        USING DYNAREA,R11

        LA R2,DSA
        ST R2,8(,R13)
        ST R13,DSA+4
        LR R13,R2
*
* Body
* Write Hello World to STDOUT
*

*
* Store values into parameter list
*
        MVC REC(HWL),HW
        LA  R1,REC
        ST  R1,RECA
        LA  R1,HWL
        ST  R1,RECL
        L   R1,STDOUT
        ST  R1,FD
        L   R1,BPXALET
        ST  R1,ALET

        CALL  BPX1WRT,(FD,                                             x
               RECA,                                                   x
               ALET,                                                   x
               RECL,                                                   x
               RV,                                                     x
               RC,                                                     x
               RN),MF=(E,BPXWRTD)

        L   R8,RV
        L   R9,RC
        L   R10,RN
*
* Epilog
*
        L   R13,DSA+4
        STORAGE RELEASE,LENGTH=DYNL,ADDR=(R11)
        RETURN (14,12),RC=0

*
* Statics, Dynamic Storage, Equates follows
*
* Naming convention:
* Suffixes:
*  L : length
*  S : static
*  D : dynamic
*  A : address

        LTORG
*
* Statics (constants)
*
STDIN   DC F'0'
STDOUT  DC F'1'
STDERR  DC F'2'
BPXALET DC F'0'
BPX1WRT DC V(BPX1WRT)

BPXWRTS CALL  ,(0,0,0,0,0,0,0),MF=L
BPXWRTL EQU *-BPXWRTS

HW      DC C'Hello World'
NEWLINE DC X'15'
HWL     EQU *-HW

*
* Dynamic (storage obtain'ed) area
*
DYNAREA DSECT
*
* Dynamic Save Area regs always first
*
DSA   DS 18F

*
* Working storage
*
FD      DS  F

RECSIZE EQU RECEND-*
REC     DS CL80
RECEND  EQU *
RECA    DS  A
BPXWRTD DS  CL(BPXWRTL)
ALET    DS  F
RECL    DS  F
RV      DS  F
RC      DS  F
RN      DS  F

DYNL EQU *-DYNAREA
*
*
* End of working storage
*

*
* Equates
*
R0      EQU 0
R1      EQU 1
R2      EQU 2
R3      EQU 3
R4      EQU 4
R5      EQU 5
R6      EQU 6
R7      EQU 7
R8      EQU 8
R9      EQU 9
R10     EQU 10
R11     EQU 11
R12     EQU 12
R13     EQU 13
R14     EQU 14
R15     EQU 15
        END

IBM Z HL/ASM

Using Modern IBM Z High Level assembler to write 'Hello World' to the Unix System Services 'stdout' file descriptor

        PRINT ON,GEN,DATA
HELLO   CSECT
HELLO   RMODE ANY
HELLO   AMODE 31
*
* Prolog
*
        SAVE (14,12)
        BASR R12,0
        USING *,R12
        STORAGE OBTAIN,LENGTH=DYNL,ADDR=(R11)
        USING DYNAREA,R11

        LA R2,DSA
        ST R2,8(,R13)
        ST R13,DSA+4
        LR R13,R2
*
* Body
* Write Hello World to STDOUT
*

*
* Store values into parameter list
*
        MVC REC(HWL),HW
        LA  R1,REC
        ST  R1,RECA
        LA  R1,HWL
        ST  R1,RECL
        L   R1,STDOUT
        ST  R1,FD
        L   R1,BPXALET
        ST  R1,ALET

        CALL  BPX1WRT,(FD,                                             x
               RECA,                                                   x
               ALET,                                                   x
               RECL,                                                   x
               RV,                                                     x
               RC,                                                     x
               RN),MF=(E,BPXWRTD)

        L   R8,RV
        L   R9,RC
        L   R10,RN
*
* Epilog
*
        L   R13,DSA+4
        STORAGE RELEASE,LENGTH=DYNL,ADDR=(R11)
        RETURN (14,12),RC=0

*
* Statics, Dynamic Storage, Equates follows
*
* Naming convention:
* Suffixes:
*  L : length
*  S : static
*  D : dynamic
*  A : address

        LTORG
*
* Statics (constants)
*
STDIN   DC F'0'
STDOUT  DC F'1'
STDERR  DC F'2'
BPXALET DC F'0'
BPX1WRT DC V(BPX1WRT)

BPXWRTS CALL  ,(0,0,0,0,0,0,0),MF=L
BPXWRTL EQU *-BPXWRTS

HW      DC C'Hello World'
NEWLINE DC X'15'
HWL     EQU *-HW

*
* Dynamic (storage obtain'ed) area
*
DYNAREA DSECT
*
* Dynamic Save Area regs always first
*
DSA   DS 18F

*
* Working storage
*
FD      DS  F

RECSIZE EQU RECEND-*
REC     DS CL80
RECEND  EQU *
RECA    DS  A
BPXWRTD DS  CL(BPXWRTL)
ALET    DS  F
RECL    DS  F
RV      DS  F
RC      DS  F
RN      DS  F

DYNL EQU *-DYNAREA
*
*
* End of working storage
*

*
* Equates
*
R0      EQU 0
R1      EQU 1
R2      EQU 2
R3      EQU 3
R4      EQU 4
R5      EQU 5
R6      EQU 6
R7      EQU 7
R8      EQU 8
R9      EQU 9
R10     EQU 10
R11     EQU 11
R12     EQU 12
R13     EQU 13
R14     EQU 14
R15     EQU 15
        END

4DOS Batch

echo Hello world!

4ME

P:hw
out{Hello 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		; C64 KERNEL ROM, output a character to current device.
			; use $fded for Apple 2, $ffe3 (ascii) or $ffee (raw) for BBC.
	.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	"Hello world!", a_cr, 0

6800 Assembly

        .cr  6800
        .tf  gbye6800.obj,AP1
        .lf  gbye6800
;=====================================================;
;        Hello world! for the Motorola 6800        ;
;                 by barrym 2013-03-17                ;
;-----------------------------------------------------;
; Prints the message "Hello 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  "Hello world!",#13,#10,#0
        .en

8080 Assembly

	; This is Hello World, written in 8080 assembly to run under CP/M
	; As you can see, it is similar to the 8086, and CP/M is very
	; similar to DOS in the way it is called.
	org	100h	; CP/M .COM entry point is 100h - like DOS
	mvi	c,9	; C holds the syscall, 9 = print string - like DOS
	lxi	d,msg	; DE holds a pointer to the string
	jmp	5	; CP/M calls are accessed through the jump at 05h
	; Normally you'd CALL it, but since you'd end the program by RETurning,
	; JMP saves a byte (if you've only got 64k of address space you want to
	; save bytes). 
msg:	db	'Hello world!$'

8086 Assembly

DOSSEG
.MODEL TINY
.DATA
TXT DB "Hello 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 "Hello world!$"

8th

"Hello world!\n" . bye

AArch64 Assembly

.equ STDOUT, 1
.equ SVC_WRITE, 64
.equ SVC_EXIT, 93

.text
.global _start

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

msg:	.ascii "Hello World!\n"
.align 4

ABAP

REPORT zgoodbyeworld.
  WRITE 'Hello world!'.

ACL2

(cw "Hello world!~%")

Acornsoft Lisp

Since there is no string data type in the language, a symbol (an identifier or 'character atom') must be used instead. When writing a symbol in source code, exclamation mark is an escape character that allows characters such as spaces and exclamation marks to be treated as part of the symbol's name. Some output functions will include exclamation mark escapes when outputting such symbols, and others, such as printc, will not.

(printc 'Hello! world!!)

The single quote in front of Hello! world!! makes it an expression that evaluates to the symbol itself; otherwise, it would be treated as a variable and its value (if it had one) would be printed instead.

Action!

Proc Main()
 Print("Hello world!")
Return

ActionScript

trace("Hello world!");

Ada

Works with: GCC version 4.1.2
with Ada.Text_IO; use Ada.Text_IO;
procedure Main is
begin
  Put_Line ("Hello world!");
end Main;

Agda

For Agda 2.6.3, based on its documentation.

module HelloWorld where

open import Agda.Builtin.IO using (IO)
open import Agda.Builtin.Unit renaming ( to Unit)
open import Agda.Builtin.String using (String)

postulate putStrLn : String -> IO Unit
{-# FOREIGN GHC import qualified Data.Text as T #-}
{-# COMPILE GHC putStrLn = putStrLn . T.unpack #-}

main : IO Unit
main = putStrLn "Hello world!"

Agena

print( "Hello world!" )

Aime

o_text("Hello world!\n");

or:

integer
main(void)
{
    o_text("Hello world!\n");

    return 0;
}

Algae

printf("Hello world!\n");

ALGOL 60

'BEGIN'
    OUTSTRING(1,'('Hello world!')');
    SYSACT(1,14,1)
'END'

ALGOL 68

main: (
  printf($"Hello world!"l$)
)

ALGOL W

begin
    write( "Hello world!" )
end.

ALGOL-M

BEGIN
    WRITE( "Hello world!" );
END

Alore

Print('Hello world!')

Amazing Hopper

1)

main:
   {"Hello world!\n"}print
exit(0)
execute with:  hopper helloworld.com

2)

#include <hopper.h>
main:
   exit("Hello world!\n")
execute with:  hopper helloworld.com -d

3)

main:
  {"Hello world!\n"}return
execute with:  hopper helloworld.com -d

AmbientTalk

system.println("Hello world!")

AmigaE

PROC main()
  WriteF('Hello world!\n')
ENDPROC

AngelScript

void main() { print("Hello world\n"); }

AntLang

Note, that "Hello, World!" prints twice in interactive mode. One time as side-effect and one as the return value of echo.

echo["Hello, World!"]

Anyways

There was a guy called Hello World
"Ow!" it said.
That's all folks!

APL

'Hello world!'

AppleScript

To show in Script Editor Result pane:

"Hello world!"

To show in Script Editor Event Log pane:

log "Hello 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 "Hello world!"

Apricot

(puts "Hello world!")

Arc

(prn "Hello world!")

Arendelle

"Hello world!"

Argile

use std
print "Hello world!"

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

ARM Assembly

.global main

message:
    .asciz "Hello world!\n"
    .align 4

main:
    ldr r0, =message
    bl printf

    mov r7, #1
    swi 0

Alternative versions

 Developed on an Acorn A5000 with RISC OS 3.10 (30 Apr 1992)
 Using the assembler contained in ARM BBC BASIC V version 1.05 (c) Acorn 1989

The Acorn A5000 is the individual computer used to develop the code,
the code is applicable to all the Acorn Risc Machines (ARM)
produced by Acorn and the StrongARM produced by digital.

 In the BBC BASIC part of the program I have included:
    OS_WriteC  = &00
    OS_WriteO  = &02
    OS_NewLine = &03
 this is so I can write SWI OS_WriteC etc instead of SWI &0 to make the assembler more legible

 (a) method1 - output the text character by character until the terminating null (0) is seen

     .method1_vn00
           ADR     R8  , method1_string    \ the ARM does not have an ADR instruction
                                           \ the assembler will work out how far the data item
                                           \ is from here (in this case a +ve relative offset)
                                           \ and so will produce an ADD R8 , PC, offset to method1_string
                                           \ a magic trick by the ARM assembler

     .method1_loop
           LDRB     R0  , [R8], #1         \ load the byte found at address in R8 into R0
                                           \ then post increment the address in R8 in preparation
                                           \ for the next byte (the #1 is my choice for the increment)
           CMP      R0  , #0               \ has the terminating null (0) been reached
           SWINE    OS_WriteC              \ when not the null output the character in R0
                                           \ (every opportunity to have a SWINE in your program should be taken)
           BNE      method1_loop           \ go around the loop for the next character if not reached the null

           SWI      OS_NewLine             \ up to you if you want a newline

           MOVS     PC  , R14              \ return
                                           \ when I call an operating system function it no longer operates
                                           \ in 'user mode' and it has its own R14, and anyway the operating system
                                           \ is too polite to write rubbish into this return address


     .method1_string
           EQUS "Hello world!"             \ the string to be output
           EQUB &00                        \ a terminating null (0)
           ALIGN                           \ tell the assembler to ensure that the next item is on a word boundary




 (b) method2 - get the supplied operating system to do the work

     .method2_vn00
           ADR     R0   , method2_string   \ the ARM does not have an ADR instruction
                                           \ the assembler will work out how far the data item
                                           \ is from here (in this case a +ve relative offset)
                                           \ and so will produce an ADD R0 , PC, offset to method2_string
                                           \ a magic trick by the ARM assembler

           SWI      OS_WriteO              \ R0 = pointer to null-terminated string to write

           SWI      OS_NewLine             \ up to you if you want a newline

           MOVS    PC   , R14              \ return
 
     .method2_string
           EQUS "hELLO WORLD!"             \ the string to be output
           EQUB &00                        \ a terminating null (0)
           ALIGN                           \ tell the assembler to ensure that the next item is on a word boundary

ArnoldC

IT'S SHOWTIME
TALK TO THE HAND "Hello world!"
YOU HAVE BEEN TERMINATED

Arturo

print "Hello world!"
Output:
Hello world!

AsciiDots

.-$'Hello, World!'

Astro

print "Hello world!"

Asymptote

write('Hello world!');

Atari BASIC

10 PRINT "Hello World"

ATS

implement main0 () = print "Hello 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 Hello world!{!}

AutoIt

ConsoleWrite("Hello world!" & @CRLF)

AutoLISP

(printc "Hello World!")

Avail

Print: "Hello World!";

AWK

BEGIN{print "Hello 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 "Hello 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). Or instead of //, simply 1 is true.

//  { 
    print "Hello world!" 
    exit
    }


For a "single record" file.

//  { 
    print "Hello world!" 
    }

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

//

Axe

Note that the i here is the imaginary i, not the lowercase letter i.

Disp "Hello world!",i

B

Works with: The Amsterdam Compiler Kit - B version V6.1pre1
main()
{
    putstr("Hello world!*n");
    return(0);
}

B4X

Log("Hello world!")

Babel

"Hello world!" <<

BabyCobol

      * Since no quotes are used, two undeclared fields (variables) are printed.
      * Their default values are their own names in uppercase.
       IDENTIFICATION DIVISION.
           PROGRAM-ID. USER OUTPUT.
       PROCEDURE DIVISION.
           DISPLAY HELLO WORLD.

Bait

fun main() {
    println('Hello World!')
}

Ballerina

import ballerina/io; 

public function main() {
    io:println("Hello World!"); 
}

bash

echo "Hello world!"

BASIC

Works with: BASICA
Works with: Chipmunk Basic
Works with: Commodore BASIC
Works with: GW-BASIC
Works with: IS-BASIC
Works with: Just BASIC
Works with: Liberty BASIC
Works with: Locomotive Basic
Works with: M2000 Interpreter
Works with: MSX BASIC
Works with: QBasic
Works with: Quite BASIC
Works with: Run BASIC
Works with: Tiny BASIC
Works with: ZX Spectrum Basic
10 print "Hello world!"


Works with: 7Basic
Works with: Applesoft BASIC
Works with: BaCon
Works with: BASIC256
Works with: FreeBASIC
Works with: IS-BASIC
Works with: M2000 Interpreter
Works with: QBasic
Works with: QB64
Works with: Script Basic
Works with: SmallBASIC
Works with: Yabasic
PRINT "Hello world!"

BASIC256

PRINT "Hello world!"

Batch File

Under normal circumstances, when delayed expansion is disabled

echo Hello world!

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

setlocal enableDelayedExpansion
echo Hello world!^^!

Battlestar

const hello = "Hello world!\n"

print(hello)

BBC BASIC

      PRINT "Hello world!"

bc

"Hello world!
"

BCPL

GET "libhdr"

LET start() = VALOF
{ writef("Hello world!")
  RESULTIS 0
}

Beef

Using System;
namespace HelloWorld {
  class Program
  {
    static void Main()
    {
      Console.Writeln("Hello World!");
    }
  }
}

beeswax

Straightforward:

*`Hello, World!

Less obvious way:

>`ld!
`
 r
  o
   W
    `
     b` ,olleH`_

Even less obvious, demonstrating the creation and execution order of instruction pointers, and the hexagonal layout of beeswax programs:

r  l
 l o
  ``
ol`*`,d!
   ``
   e H
   W

Befunge

52*"!dlroW ,olleH">:#,_@

Binary Lambda Calculus

As explained at https://www.ioccc.org/2012/tromp/hint.html

 Hello world!

Bird

It's not possible to print exclamation marks in Bird which is why it is not used in this example.

use Console

define Main
    Console.Println "Hello world"
end

Blade

echo 'Hello world!'

or

print('Hello world!')

or

import io
io.stdout.write('Hello world!')

Blast

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

BlitzMax

print "Hello world!"

Blue

Linux/x86

global _start

: syscall ( num:eax -- result:eax ) syscall ;

: exit ( status:edi -- noret ) 60 syscall ;
: bye ( -- noret ) 0 exit ;

1 const stdout

: write ( buf:esi len:edx fd:edi -- ) 1 syscall drop ;
: print ( buf len -- ) stdout write ;

: greet ( -- ) s" Hello world!\n" print ;

: _start ( -- noret ) greet bye ;

blz

print("Hello world!")

BML

display "Hello world!"

Boo

print "Hello world!"

bootBASIC

10 print "Hello world!"

BQN

Works in: CBQN

•Out "Hello world!"

Brace

#!/usr/bin/env bx
use b
Main:
	say("Hello world!")

Bracmat

put$"Hello 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*** :)

Brat

p "Hello world!"

Brlcad

The mged utility can output text to the terminal:

echo Hello world!

Bruijn

Ignore stdin by not referring to the abstraction:

main ["Hello world!"]

Burlesque

"Hello 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("Hello world!\n");
  return EXIT_SUCCESS;
}

Or:

#include <stdlib.h>
#include <stdio.h>

int main(void)
{
  puts("Hello world!");
  return EXIT_SUCCESS;
}

Or, the eternal favourite :)

#include<stdio.h>

int main()
{
  printf("\nHello world!");
  return 0;
}

or better yet...

#include<stdio.h>

int main()
{
	return printf("\nHello World!");
}

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("Hello world!");
        }
    }
}
Works with: Visual C# version 9.0+

C# 9.0 allows statements at the top level of a source file (a compilation_unit in the specification) between any using statements and namespace declarations. These statements become the program entry point and are placed in a method in a compiler-generated type.

System.Console.WriteLine("Hello world!");

or

using System;
Console.WriteLine("Hello world!");

C++

#include <iostream>

int main() {
  std::cout << "Hello world!\n";
}

Since C++23’s addition of the <print> header and the standard library module std we could now write this:

import module std; // here does the same thing as #include <print>

int main() {
  std::print("Hello world!\n");
}

C++/CLI

using namespace System;
int main()
{
  Console::WriteLine("Hello world!");
}

C1R

Hello_world/Text
Output:
$ echo Hello_world/Text >hw.c1r
$ ./c1r hw.c1r
$ ./a.out
Hello world!

C2

module hello_world;
import stdio as io;

func i32 main(i32 argc, char** argv) {
    io.printf("Hello World!\n");
    return 0;
}

C3

import std::io;

fn void main() 
{
    io::printn("Hello, World!");
}

Casio BASIC

Locate 1,1,"Hello World!"

or just

"Hello World!"

Cat

"Hello world!" writeln

Cduce

print "Hello world!";;

CFEngine

#!/usr/bin/env cf-agent
# without --no-lock option to cf-agent
# this output will only occur once per minute
# this is by design.
bundle agent main
{
  reports:
    "Hello world!";
}

See https://docs.cfengine.com/docs/master/examples.html for a more complete example and introduction.

Chapel

writeln("Hello 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.

Chipmunk Basic

10 print "Hello world!"

ChucK

<<< "Hello world!">>>;

Cind

execute() {
    host.println("Hello world!");
}

Clay

main() {
    println("Hello world!");
}

Clean

Start = "Hello world!"

Clio

'hello world!' -> print

Clipper

? "Hello world!"

CLIPS

(printout t "Hello world!" crlf)

CLU

start_up = proc ()
    po: stream := stream$primary_output()
    stream$putl(po, "Hello world!")
end start_up

Clojure

(println "Hello world!")

CMake

message(STATUS "Hello world!")

This outputs

-- Hello world!

COBOL

Using fixed format.

Works with: OpenCOBOL
	program-id. hello.
	procedure division.
		display "Hello world!".
		stop run.

Using relaxed compilation rules, the hello program can become a single DISPLAY statement.

Works with: GnuCOBOL
display"Hello, world".
prompt$ cobc -x -frelax-syntax -free hello.cob
hello.cob: 1: Warning: PROGRAM-ID header missing - assumed
hello.cob: 1: Warning: PROCEDURE DIVISION header missing - assumed

prompt$ ./hello
Hello, world

Note how COBOL can handle the DISPLAY reserved word without a space before the quoted string, the quote being a compile time scan delimiter. The full stop period after the single statement is still mandatory, at least for GnuCOBOL and a clean compile to executable.

Cobra

class Hello
    def main
        print 'Hello world!'

CoffeeScript

Works with: Node.js
console.log "Hello world!"
Works with: Rhino engine
print "Hello world!"

ColdFusion

<cfoutput>Hello world!</cfoutput>

Comal

PRINT "Hello world!"

Comefrom0x10

'Hello world!'
"Hello world!"

Commodore BASIC

By default some Commodore computers boot into uppercase/graphics mode (C64, C128, VIC-20, Plus 4, etc.) while others (PET, CBM etc.) boot into lowercase/uppercase mode. Therefore, depending on machine used, the CHR$(14) may or may not be required to switch into mixed-case mode.

10 print chr$(147);chr$(14);:REM 147=clear screen, 14=switch to lowercase mode
20 print "Hello world!"
30 end
Output:
Hello world!

Common Lisp

(format t "Hello world!~%")

Or

(print "Hello world!")

Alternate solution

I use Allegro CL 10.1

;; Project : Hello world/Text

(format t "~a" "Hello world!")

Output:

Hello world!

Component Pascal

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

Run command Hello.Do by commander.

Coq

Require Import Coq.Strings.String.

Eval compute in ("Hello world!"%string).

Corescript

print Hello world!

Cowgol

include "cowgol.coh";
print("Hello world!");
print_nl();


Crack

import crack.io cout;
cout `Hello world!\n`;

Craft Basic

print "Hello world!"

Creative Basic

OPENCONSOLE

PRINT"Hello 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 "Hello world!"

Curto

." Hola, mundo!"

D

Works with: D version 2.0
import std.stdio;

void main() {
    writeln("Hello world!");
}

Dafny

method Main() {
  print "hello, world!\n";
  assert 10 < 2;
}

Dao

io.writeln( 'Hello world!' )

Dart

main() {
    var bye = 'Hello world!';
    print("$bye");
}

DataWeave

"Hello world!"

DBL

;
;       Hello world for DBL version 4 by Dario B.
;
                                PROC
;------------------------------------------------------------------
        XCALL FLAGS (0007000000,1)           ;Suppress STOP message

        OPEN (1,O,'TT:')
        WRITES (1,"Hello world")

        DISPLAY (1,"Hello world",10)
        DISPLAY (1,$SCR_MOV(-1,12),"again",10)  ;move up, right and print

        CLOSE 1
END

Dc

[Hello world!]p

...or print a numerically represented string.

5735816763073014741799356604682 P

DCL

$ write sys$output "Hello world!"

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

Delphi

program ProjectGoodbye;
{$APPTYPE CONSOLE}
begin
  WriteLn('Hello world!');
end.

DeviousYarn

o:"Hello world!

DIBOL-11

          START     ;Hello World

          RECORD  HELLO
,         A11, 'Hello World'

          PROC
          XCALL FLAGS (0007000000,1)          ;Suppress STOP message

          OPEN(8,O,'TT:')
          WRITES(8,HELLO)
          END

Diego

Once the caller has met the computer and its printer...

with_computer(comp1)_printer(lp1)_text(Hello World!);

If the caller is the computer...

with_me()_printer(lp1)_text(Hello World!);

...or can be shortened as...

me()_ptr(lp1)_txt(Hello World!);

If the computer has more than one printer...

me()_printer()_text(Hello World!);

If there are more than one computer which have zero or more printers...

with_computer()_printer()_text(Hello World!);

If there are zero or more printers connected to any thing (device)...

with_printer()_text(Hello World!);

DIV Games Studio

PROGRAM HELLOWORLD;

BEGIN

    WRITE_TEXT(0,160,100,4,"HELLO WORLD!");
    LOOP
        FRAME;
    END
END

DM

/client/New()
    ..()
    src << "Hello world!"

Draco

proc nonrec main() void:
    writeln("Hello world!")
corp

Dragon

showln "Hello world!"

DreamBerd

print "Hello world!"!

dt

"Hello world!" pl

DWScript

PrintLn('Hello world!');

Dyalect

print("Hello world!")

Dylan

module: hello-world

format-out("%s\n", "Hello 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("Hello 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("Hello world!")
   end method

end class

Déjà Vu

!print "Hello world!"

E

println("Hello world!")

stdout.println("Hello world!")

EasyLang

print "Hello world!"

eC

class GoodByeApp : Application
{
   void Main()
   {
      PrintLn("Hello world!");
   }
}

EchoLisp

(display "Hello world!" "color:blue")

ECL

OUTPUT('Hello world!');

Ecstasy

module HelloWorld {
    void run() {
        @Inject Console console;
        console.print("Hello, World!");
    }
}

Ed

a
Hello World!
.
p
Q

EDSAC order code

The EDSAC did not support lower-case letters. The method used here is to include a separate O order to print each character: for short messages and labels this is quite adequate. A more general (though slightly more involved) solution for printing strings is given at Hello world/Line printer#EDSAC order code.

[ Print HELLO WORLD ]
[ A program for the EDSAC ]
[ Works with Initial Orders 2 ]

T64K  [ Set load point: address 64 ]
GK    [ Set base address ]
O13@  [ Each O order outputs one ]
O14@  [ character. The numerical ]
O15@  [ parameter gives the offset ]
O16@  [ (from the base address) where ]
O17@  [ the character to print is ]
O18@  [ stored ]
O19@
O20@
O21@  
O22@
O23@
O24@
ZF    [ Stop ]
*F    [ Shift to print letters ]
HF    [ Character literals ]
EF
LF
LF
OF
!F    [ Space character ]
WF
OF
RF
LF
DF
EZPF  [ Start program beginning at
        the load point ]
Output:
HELLO WORLD

Efene

short version (without a function)

io.format("Hello world!~n")

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

@public 
run = fn () {
    io.format("Hello world!~n")
}

Egel

def main = "Hello World!"

Egison

(define $main
  (lambda [$argv]
    (write-string "Hello world!\n")))

EGL

Works with: EDT
Works with: RBD
program HelloWorld
    function main()
        SysLib.writeStdout("Hello world!");
    end
end

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 ("Hello world!%N")
        end
end

Ela

open monad io
do putStrLn "Hello world!" ::: IO

Elan

putline ("Hello, 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( "Hello world!\n" );
    }

    /*
     *  Here we start to execute package code
     */

    // Invoke the `hello' function
    hello();

Elena

ELENA 6.x:

public program()
{
    console.writeLine("Hello world!")
}

Elisa

 "Hello world!"?

Elixir

IO.puts "Hello world!"

Elm

main = text "Goodbye World!"

Emacs Lisp

(message "Hello world!")

Alternatively, princ can be used:

(princ "Hello world!\n")

EMal

writeLine("Hello world!")

Emojicode

🏁 🍇
  😀 🔤Hello world!🔤
🍉

Enguage

This shows "hello world", and shows how Enguage can generate this program on-the-fly.

On "say hello world", reply "hello world".

## This can be tested:
#] say hello world: hello world.

## This can also be created within Enguage:
#] to the phrase hello reply hello to you too: ok.
#] hello: hello to you too.

Output:

TEST: hello
===========

user> say hello world.
enguage> hello world.

user> to the phrase hello reply hello to you too.
enguage> ok.

user> hello.
enguage> hello to you too.
1 test group(s) found
+++ PASSED 3 tests in 53ms +++

Erlang

io:format("Hello world!~n").

ERRE

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

Euler Math Toolbox

"Hello world!"

Extended BrainF***

[.>]@Hello world!

Ezhil

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

F#

printfn "%s" "Hello world!"

or using .Net classes directly

System.Console.WriteLine("Hello world!")

Factor

"Hello world!" print

Falcon

With the printl() function:

printl("Hello world!")

Or via "fast print":

> "Hello world!"

FALSE

"Hello world!
"

Fantom

class HelloText
{
  public static Void main ()
  {
    echo ("Hello world!")
  }
}

Fe

(print "Hello World")

Fennel

(print "Hello World")

ferite

word.}}

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

Fermat

!!'Hello, World!';

Fexl

say "Hello world!"

Fhidwfe

puts$ "Hello, world!\n"

Fish

Standard Hello, world example, modified for this task:

!v"Hello 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 Hello 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.

FOCAL

TYPE "Hello, world" !

Forth

." Hello world!"

Or as a whole program:

: goodbye ( -- )   ." Hello world!" CR ;

Fortran

Works with: F77

Simplest case - display using default formatting:

print *,"Hello world!"

Use explicit output format:

100   format (5X,A,"!")
      print 100,"Hello world!"

Output to channels other than stdout goes like this:

write (89,100) "Hello 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". Template:7*7

Fortress

export Executable                                                                                                                       
                                                                                                                                        
run() = println("Hello world!")

FreeBASIC

? "Hello world!"
sleep


Free Pascal

PROGRAM HelloWorld ;

{$APPTYPE CONSOLE}

(*) 

        https://www.freepascal.org/advantage.var

(*)

USES

    crt;

BEGIN

  WriteLn ( 'Hello world!' ) ;

END.

Frege

Works with: Frege version 3.20.113
module HelloWorld where
main _ = println "Hello world!"

friendly interactive shell

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

echo Hello world!

Frink

println["Hello world!"]

FTCBASIC

print "Hello, world!"
pause
end

FunL

println( 'Hello world!' )


Furor

."Hello, World!\n"

Peri

."Hello, World!\n"

FutureBasic

window 1
print @"Hello world!"

HandleEvents

FUZE BASIC

PRINT "Hello world!"

Gambas

Click this link to run this code

Public Sub Main()

PRINT "Hello world!"
 
End

GAP

# Several ways to do it
"Hello world!";

Print("Hello world!\n"); # No EOL appended

Display("Hello world!");

f := OutputTextUser();
WriteLine(f, "Hello world!\n");
CloseStream(f);

GB BASIC

10 print "Hello world!"

gecho

'Hello, <> 'World! print

Gema

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

*= ! ignore off content of input
\B=Hello world!\! ! Start output with this text.

Genie

init
    print "Hello world!"

Gentee

func hello <main>
{
   print("Hello world!")
}

GFA Basic

PRINT "Hello World"

GLBasic

STDOUT "Hello world!"

Gleam

import gleam/io

pub fn main() {
    io.println("Hello world!")
}

Glee

"Hello world!"

or

'Hello world!'

or to display with double quotes

 '"Goodbye,World!"'

or to display with single quotes

 "'Goodbye,World!'"

Global Script

This uses the gsio I/O operations, which are designed to be simple to implement on top of Haskell and simple to use.

λ _. print qq{Hello world!\n}

GlovePIE

debug="Hello world!"

GML

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

Go

package main

import "fmt"

func main() { fmt.Println("Hello world!") }

Golfscript

"Hello world!"

Gosu

print("Hello world!")

Grain

print("Hello world!")

Groovy

println "Hello world!"

GW-BASIC

10 PRINT "Hello world!"

Hack

<?hh echo 'Hello world!'; ?>

Halon

If the code in run in the REPL the output will be to stdout otherwise syslog LOG_DEBUG will be used.

echo "Hello world!";

Harbour

? "Hello world!"

Hare

use fmt;

export fn main() void = {
	fmt::println("Hello, world!")!;
};

Haskell

main = putStrLn "Hello world!"

Haxe

trace("Hello world!");

hexiscript

println "Hello world!"

HicEst

WRITE() 'Hello world!'

HLA

program goodbyeWorld;
#include("stdlib.hhf")
begin goodbyeWorld;

  stdout.put( "Hello world!" nl );

end goodbyeWorld;

HolyC

"Hello world!\n";

Hoon

~&  "Hello world!"  ~

Hopper

program Hello
{
    uses "/Source/Library/Boards/PiPico"
    
    Hopper()
    {
        WriteLn("Hello world!");
        loop
        {
            LED = !LED;
            Delay(500);
        }
    }
}
Output:

In IDE, build hello.hs into hello.hexe, (press F7) and start debug (F5) or hm console monitor.

!> hello
Hello world!

The language and runtime install verification message shows up on the monitor console. In keeping with most MCU introductions, the onboard Light Emitting Diode (LED) will then blink on and off at 1/2 second intervals, forever; (until power runs out, or explicit operator intervention).

HPPPL

PRINT("Hello world!");

HQ9+

This example is incorrect. Please fix the code and remove this message.

Details: output isn't consistent with the task's requirements (and is probably incapable of solving the task).

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

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

Huginn

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

main() {
	print( "Hello World!\n" );
	return ( 0 );
}

HTML5

<!DOCTYPE html>
<html>
<body>
<h1>Hello world!</h1>
</body>
</html>

Hy

(print "Hello world!")

i

software {
    print("Hello world!")
}

Icon and Unicon

procedure main()
  write( "Hello world!" )
end

IDL

print,'Hello world!'

Idris

module Main

main : IO ()
main = putStrLn "Hello world!"

Inform 6

[Main;
  print "Hello world!^";
];

Inko

import std::stdio::stdout

stdout.print('Hello, world!')

Insitux

(print "Hello, world!")

Intercal

DO ,1 <- #13
PLEASE DO ,1 SUB #1 <- #238
DO ,1 SUB #2 <- #108
DO ,1 SUB #3 <- #112
DO ,1 SUB #4 <- #0
DO ,1 SUB #5 <- #64
DO ,1 SUB #6 <- #194
PLEASE DO ,1 SUB #7 <- #48
DO ,1 SUB #8 <- #26
DO ,1 SUB #9 <- #244
PLEASE DO ,1 SUB #10 <- #168
DO ,1 SUB #11 <- #24
DO ,1 SUB #12 <- #16
DO ,1 SUB #13 <- #162
PLEASE READ OUT ,1
PLEASE GIVE UP


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 "Hello world!"
   20 END

Io

"Hello world!" println

Ioke

"Hello world!" println

IS-BASIC

PRINT "Hello world!"

Isabelle

theory Scratch
  imports Main
begin
  value ‹''Hello world!''›
end

IWBASIC

OPENCONSOLE

PRINT"Hello 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

   'Hello world!'
Hello world!

Here are some redundant alternatives:

   [data=. 'Hello world!'
Hello world!
   data
Hello world!
   smoutput data
Hello world!

   NB. unassigned names are verbs of infinite rank awaiting definition.
   NB. j pretty prints the train.
   Hello World!
Hello World !


   NB. j is glorious, and you should know this!

   i. 2 3   NB. an array of integers
0 1 2
3 4 5

   verb_with_infinite_rank =: 'Hello world!'"_

   verb_with_infinite_rank i. 2 3
Hello world!
   

   verb_with_atomic_rank =: 'Hello world!'"0

   verb_with_atomic_rank i. 2 3
Hello world!
Hello world!
Hello world!

Hello world!
Hello world!
Hello world!

Jack

class Main {
  function void main () {
    do Output.printString("Hello world!");
    do Output.println();
    return;
  }
}

Jacquard Loom

This weaves the string "Hello world!"

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

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

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

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

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

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

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

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

Jai

#import "Basic";

main :: () {
    print("Hello, World!\n");
}

Jakt

fn main() {
    println("Hello world!")
}

Janet

(print "Hello world!")

Java

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

JavaScript

document.write("Hello world!");
Works with: NJS version 0.2.5
Works with: Rhino
Works with: SpiderMonkey
print('Hello world!');
Works with: JScript
WScript.Echo("Hello world!");
Works with: Node.js
console.log("Hello world!")

JCL

/*MESSAGE Hello world!

Jinja

from jinja2 import Template
print(Template("Hello World!").render())

A bit more convoluted, really using a template:

from jinja2 import Template
print(Template("Hello {{ something }}!").render(something="World"))

Joy

"Hello world!\n" putchars.

jq

"Hello world!"

JSE

Print "Hello world!"

Jsish

puts("Hello world!")

Julia

println("Hello world!")

K

"Hello world!"

Some of the other ways this task can be attached are:

`0: "Hello world!\n"
s: "Hello world!"
s
\echo "Hello world!"

Kabap

return = "Hello world!";

Kaya

program hello;
 
Void main() {
    // My first program!
    putStrLn("Hello world!");
}

Kdf9 Usercode

This example is incorrect. Please fix the code and remove this message.

Details: output isn't consistent with the task's requirements: wording, punctuation.

 

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;

Keg

Hello world\!

Kite

simply a single line

"#!/usr/local/bin/kite

"Hello world!"|print;

Kitten

"Hello world!" say

KL1

:- module main.

main :-
      unix:unix([stdio(normal(S))]),
      S = [fwrite("Hello world\n")].

Koka

fun main() {
  println("Hello world!")
}

Alternatively:

- indentation instead of braces

- uniform function call syntax

- omitted parentheses for function calls with no parameters

fun main()
  "Hello world!".println

KonsolScript

Displays it in a text file or console/terminal.

function main() {
  Konsol:Log("Hello world!")
}

Kotlin

fun main() {
    println("Hello world!")
}

KQL

print 'Hello world!'

KSI

`plain
'Hello world!' #echo #

Lambdatalk

Hello world!
{h1 Hello world!}
_h1 Hello world!\n

Lang

fn.println(Hello world!)

Lang5

"Hello world!\n" .

langur

writeln "Hello"

Lasso

A plain string is output automatically.

'Hello world!'

LaTeX

\documentclass{minimal}
\begin{document}
Hello World!
\end{document}

Latitude

putln "Hello world!".

LC3 Assembly

.orig x3000
LEA R0, hello    ; R0 = &hello
TRAP x22         ; PUTS (print char array at addr in R0)
HALT
hello .stringz "Hello World!"
.end

Or (without PUTS)

.orig x3000
LEA R1, hello        ; R1 = &hello
TOP LDR R0, R1, #0   ; R0 = R1[0]
BRz END              ; if R0 is string terminator (x0000) go to END
TRAP x21             ; else OUT (write char in R0)
ADD R1, R1, #1       ;      increment R1
BR TOP               ;      go to TOP
END HALT
hello .stringz "Hello World!"
.end

LDPL

procedure:
display "Hello World!" crlf

Lean

#eval "Hello world!"

Slightly longer version:

def main : IO Unit :=
  IO.println ("Hello world!")

#eval main

LFE

(: io format '"Hello world!~n")

Liberty BASIC

print "Hello world!"

LIL

#
# Hello world in lil
#

print "Hello, world!"

Lily

There are two ways to do this. First, with the builtin print:

print("Hello world!")

Second, by using stdout directly:

stdout.print("Hello world!\n")

LilyPond

\version "2.18.2"
global = {
  \time 4/4
  \key c \major
  \tempo 4=100
}
\relative c''{ g e e( g2)
}
\addlyrics {
  Hel -- lo,   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("Hello world!\n");
 }

Lingo

put "Hello world!"

or:

trace("Hello world!")

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 <- ("Hello 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 "Hello world!\n";);

Little

Output to terminal:

puts("Hello world!");

Without the newline terminator:

puts(nonewline: "Hello world!");

Output to arbitrary open, writable file, for example the standard error channel:

puts(stderr, "Hello world!");

LiveCode

Examples using the full LiveCode IDE.

Text input and output done in the Message palette/window:

put "Hello World!"

Present a dialog box to the user

Answer "Hello World!"

Example using command-line livecode-server in shell script

#! /usr/local/bin/livecode-server
set the outputLineEndings to "lf"
put "Hello world!" & return

Livecode also supports stdout as a device to write to

write "Hello world!" & return to stdout

LLVM

; const char str[14] = "Hello World!\00"
@.str = private unnamed_addr constant  [14 x i8] c"Hello, world!\00"

; declare extern `puts` method
declare i32 @puts(i8*) nounwind

define i32 @main()
{
  call i32 @puts( i8* getelementptr ([14 x i8]* @str, i32 0,i32 0))
  ret i32 0
}

Lobster

print "Hello world!"

Print includes a line feed:

print [Hello world!]

Type does not:

type [Hello world!]

Logtalk

:- object(hello_world).

    % the initialization/1 directive argument is automatically executed
    % when the object is loaded into memory:
    :- initialization(write('Hello world!\n')).

:- end_object.

LOLCODE

HAI
CAN HAS STDIO?
VISIBLE "Hello world!"
KTHXBYE

LotusScript

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

:- end_object.

LSE

AFFICHER [U, /] 'Hello world!'

LSE64

"Hello 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 "Hello 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
  io.write(chars[i])
end
-- or:
print(table.concat(chars))

Luna

def main:
    hello = "Hello, World!"
    print hello

M2000 Interpreter

Print "Hello World!" \\ printing on columns, in various ways defined by last $() for specific layer
Print $(4),"Hello World!" \\ proportional printing using columns, expanded to a number of columns as the length of string indicates.
Report "Hello World!"  \\ proportional printing with word wrap, for text, can apply justification and rendering a range of text lines

M4

For the particular nature of m4, this is simply:

`Hello world!'

MACRO-10

        TITLE HELLO

COMMENT !
  Hello-World program, PDP-10 assembly language, written by kjx, 2022.
           Assembler: MACRO-10    Operating system: TOPS-20
!

        SEARCH MONSYM                      ;Get symbolic names for system-calls.

GO::    RESET%                             ;System call: Initialize process.

        HRROI 1,[ASCIZ /Hello World!/]     ;Put pointer to string into register 1.
        PSOUT%                             ;System call: Print string.
        HALTF%                             ;System call: Halt program.

        JRST GO                            ;Unconditional jump to GO (in case the
                                           ;user uses the CONTINUE-command while this
                                           ;program is still loaded).

        END GO

MACRO-11

;
;          TEXT BASED HELLO WORLD
;          WRITTEN  BY:  BILL GUNSHANNON
;
 
           .MCALL  .PRINT .EXIT 
           .RADIX  10
 
 
 
MESG1:     .ASCII  "  "
           .ASCII  " HELLO WORLD "
           .EVEN
 
START:
           .PRINT  #MESG1
 
DONE:
 
;   CLEAN UP AND GO BACK TO KMON
 
           .EXIT
 
 
           .END     START


Maclisp

(format t "Hello world!~%")

Or

(print "Hello world!")

MAD

           VECTOR VALUES HELLO = $11HHELLO WORLD*$
           PRINT FORMAT HELLO
           END OF PROGRAM

make

Makefile contents:

all:
$(info Hello world!)

Running make produces:

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

MANOOL

In “applicative” notation:

{{extern "manool.org.18/std/0.3/all"} in WriteLine[Out; "Hello world!"]}

OOPish notation (equivalent to the above, up to Abstract Syntax Tree):

{{extern "manool.org.18/std/0.3/all"} in Out.WriteLine["Hello world!"]}

LISPish notation (ditto):

{{extern "manool.org.18/std/0.3/all"} in {WriteLine Out "Hello world!"}}

Using a colon punctuator (ditto):

{{extern "manool.org.18/std/0.3/all"} in: WriteLine Out "Hello world!"}

Note that all semicolons, wherever allowed, are optional. The above example with all possible semicolons:

{{extern; "manool.org.18/std/0.3/all"} in: WriteLine; Out; "Hello world!"}

Maple

> printf( "Hello world!\n" ): # print without quotes
Hello world!

Mastermind

output "Hello world!\n";

Mathcad

Simply type the following directly onto a Mathcad worksheet (A worksheet is Mathcad's combined source code file & console).

"Hello, World!"

Applies to Mathcad Prime, Mathcad Prime Express and Mathcad 15 (and earlier)

Mathematica / Wolfram Language

Print["Hello world!"]

MATLAB

>> disp('Hello world!')


Maude

fmod BYE-WORLD is

	protecting STRING .
	
	op sayBye : -> String .
	
	eq sayBye = "Hello world!" .
	
endfm

red sayBye .

Maxima

print("Hello world!");

MAXScript

print "Hello world!"

or:

format "%" "Hello world!"

MDL

<PRINC "Hello world!">
<CRLF>

MEL

proc helloWorld () {
   print "Hello, world!\n";
}

MelonBasic

Say:Hello world!

helloWorld;

Mercury

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

:- implementation.
main(!IO) :-
    io.write_string("Hello world!\n", !IO).

Metafont

message "Hello world!"; end

Microsoft Small Basic

TextWindow.WriteLine("Hello world!")

min

"Hello world!" puts

Minimal BASIC

10 PRINT "Hello world!"
20 END

MiniScript

print "Hello world!"

MiniZinc

output ["Hello World"];
Output:
Hello World
----------

MIPS Assembly

Works with: MARS

and

Works with: SPIM
   .data #section for declaring variables
hello:  .asciiz "Hello world!" #asciiz automatically adds the null terminator. If it's .ascii it doesn't have it.

   .text # beginning of code
main: # a label, which can be used with jump and branching instructions.
   la $a0, hello # load the address of hello into $a0
   li $v0, 4 # set the syscall to print the string at the address $a0
   syscall # make the system call

   li $v0, 10 # set the syscall to exit
   syscall # make the system call

Miranda

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

mIRC Scripting Language

echo -ag Hello world!

ML/I

Hello world!

Modula-2

MODULE Hello;
IMPORT InOut;

BEGIN
  InOut.WriteString('Hello world!');
  InOut.WriteLn
END Hello.

TopSpeed Modula-2

Modula-2 does not have built-in procedures for I/O. Instead, I/O is done via library modules. The names and contents of these modules vary between implementations of Modula-2. The solution below shows that the console I/O module supplied with TopSpeed Modula-2 has a different name and different procedures from the implementation in the previous solution.

MODULE Hello;
IMPORT IO;

BEGIN
  IO.WrStr('Hello world!'); IO.WrLn;

(* Another way, showing some features of Modula-2 *)
  IO.WrStr("Hello");  (* either single or double quotes can be used *)
  IO.WrChar(40C);     (* character whose ASCII code is 40 octal *)
  IO.WrStr('world!');
  IO.WrLn();          (* procedure with no arguments: () is optional *)
END Hello.

Modula-3

MODULE Goodbye EXPORTS Main;

IMPORT IO;

BEGIN
  IO.Put("Hello world!\n");
END Goodbye.

MontiLang

|Hello, World!| PRINT .

Morfa

import morfa.io.print;
func main(): void
{
    println("Hello world!");
}

Mosaic

proc main =
    println "Hello, world"
end

Or just:

println "Hello, world"

MSX Basic

10 PRINT "Hello world!"

MUF

: main[ -- ]
me @ "Hello world!" notify
exit
;

MUMPS

Write "Hello world!",!

MyDef

Run with:

mydef_run hello.def

Perl:

$print Hello world

C:

module: c
$print Hello world

python:

module: python
$print Hello world

JavaScript

module: js
$print "Hello world"

go:

module: go
$print Hello world

MyrtleScript

script HelloWorld {
    func main returns: int {
        print("Hello World!")
    }
}

MySQL

SELECT 'Hello world!';

Mythryl

print "Hello world!";

N/t/roff

To get text output, compile the source file using NROFF and set output to the text terminal. If you compile using TROFF, you will get graphical output suitable for typesetting on a graphical typesetter/printer instead.

Because /.ROFF/ is a document formatting language, the majority of input is expected to be text to output onto a medium. Therefore, there are no routines to explicitly call to print text.

Hello world!

Nanoquery

println "Hello world!"

Neat

void main() writeln "Hello world!";

Neko

$print("Hello world!");

Nemerle

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

Easier method:

System.Console.WriteLine("Hello world!");

NetRexx

say  'Hello world!'

Never

func main() -> int {
    prints("Hello world!\n");
    0
}
Output:
prompt$ never -f hello.nev
Hello world!

newLISP

Works with: newLisp version 6.1 and after
(println "Hello world!")

Nickle

printf("Hello world!\n")

Nim

echo("Hello world!")

using stdout

stdout.writeLine("Hello World!")

Nit

print "Hello world!"

Nix

"Hello world!"

NLP++

@CODE
"output.txt" << "Hello world!";
@@CODE

NS-HUBASIC

As lowercase characters are not offered in NS-HUBASIC, perhaps some flexibility in the task specification could be offered.

Using ?:

10 ? "HELLO WORLD!"

Using PRINT:

10 PRINT "HELLO WORLD!"

Nu

print "Hello world!"

Nutt

module hello_world
imports native.io.output.say

say("Hello, world!")

end

Nyquist

Interpreter: Nyquist (3.15)

LISP syntax

(format t "Hello world!")

Or

(print "Hello world!")

SAL syntax

print "Hello World!"

Or

exec format(t, "Hello World!")

Oberon-2

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

Objeck

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

ObjectIcon

import io

procedure main ()
  io.write ("Hello world!")
end
Output:
$ oiscript hello-OI.icn
Hello world!

Objective-C

Works with: clang-602.0.53

The de facto Objective-C "Hello, World!" program is most commonly illustrated as the following, using the NSLog() function:

#import <Foundation/Foundation.h>

int main() {
    @autoreleasepool {
        NSLog(@"Hello, World!");
    }
}

However the purpose of the NSLog() function is to print a message to standard error prefixed with a timestamp, which does not meet the most common criteria of a "Hello, World!" program of displaying only the requested message to standard output.

The following code prints the message to standard output without a timestamp using exclusively Objective-C messages:

#import <Foundation/Foundation.h>

int main() {
    @autoreleasepool {
        NSFileHandle *standardOutput = [NSFileHandle fileHandleWithStandardOutput];
        NSString *message = @"Hello, World!\n";
        [standardOutput writeData:[message dataUsingEncoding:NSUTF8StringEncoding]];
    }
}

Objective-C also supports functions contained within the C standard library. However, Objective-C's NSString objects must be converted into a UTF-8 string in order to be supported by the C language's I/O functions.

#import <Foundation/Foundation.h>

int main() {
    @autoreleasepool {
        NSString *message = @"Hello, World!\n";
        printf("%s", message.UTF8String);
    }
}

OCaml

print_endline "Hello world!"

Occam

Works with: kroc
#USE "course.lib"
PROC main (CHAN BYTE screen!)
  out.string("Hello world!*c*n", 0, screen)
:

Octave

disp("Hello world!");

Or, using C-style function printf:

printf("Hello world!");

Odin

package main
import "core:fmt"

main :: proc() {
  fmt.println("Hellope!");
}

Oforth

"Hello world!" .

Ol

(print "Hello world!")

Onyx

`Hello world!\n' print flush

Onyx (wasm)

use core {printf}
main :: () {
    printf("Hello world!");
}
Output:
Hello world!

OOC

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

main: func {
  "Hello world!" println()
}

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

main: func {
  println("Hello world!")
}

ooRexx

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

/* Rexx */
say 'Hello world!'

OpenLisp

We can use the same code as the Common Lisp example, but as a shell script.

#!/openlisp/uxlisp -shell
(format t "Hello world!~%")
(print "Hello world!")

Output: Hello world! "Hello world!"

Openscad

echo("Hello world!");  // writes to the console
text("Hello world!");  // creates 2D text in the object space
linear_extrude(height=10) text("Hello world!"); // creates 3D text in the object space

Owl Lisp

(print "Hello world!")
Output:
$ ol hello-Owl.scm
Hello world!


Oxygene

From wp:Oxygene (programming language)

namespace HelloWorld;
 
interface
 
type
  HelloClass = class
  public
    class method Main; 
  end;
 
implementation
 
class method HelloClass.Main;
begin
  writeLn('Hello world!');
end;
 
end.
Output:
Hello world!

Oz

{Show "Hello world!"}

PARI/GP

print("Hello world!")

Pascal

Works with: Free Pascal
program byeworld;
begin
 writeln('Hello world!');
end.

PascalABC.NET

// Hello world/Text. Nigel Galloway: January 25th., 2023
begin
  System.Console.WriteLine('Hello World!');
end.

PascalABC.NET supports classical pascal syntax:

program HelloWorld;
begin
  writeln('Hello World!');
end.

New syntax for an "one line" program

##
println('Hello World!');


Output:
Hello World!

PASM

print "Hello world!\n"
end

PDP-1 Assembly

This can be assembled with macro1.c distributed with SIMH and then run on the SIMH PDP-1 simulator.

hello   
/ above: title line - was punched in human readable letters on paper tape
/ below: location specifier - told assembler what address to assemble to
100/
lup,	lac i ptr		/ load ac from address stored in pointer
	cli			/ clear io register
lu2,	rcl 6s			/ rotate combined ac + io reg 6 bits to the left
				/ left 6 bits in ac move into right 6 bits of io reg
	tyo			/ type out character in 6 right-most bits of io reg
	sza			/ skip next instr if accumulator is zero
	jmp lu2			/ otherwise do next character in current word
	idx ptr			/ increment pointer to next word in message
	sas end			/ skip next instr if pointer passes the end of message
	jmp lup			/ otherwise do next word in message
	hlt			/ halt machine
ptr,	msg			/ pointer to current word in message
msg,	text "hello, world"	/ 3 6-bit fiodec chars packed into each 18-bit word
end,	.         		/ sentinel for end of message
start 100			/ tells assembler where program starts

PDP-11 Assembly

This is Dennis Ritchie's Unix Assembler ("as"). Other PDP-11 assemblers include PAL-11R, PAL-11S and MACRO-11.

Works with: UNIX version 1

to

Works with: UNIX version 7
.globl  start
	.text
start:
        mov	$1,r0               / r0=stream, STDOUT=$1
	sys	4; outtext; outlen  / sys 4 is write
	sys	1                   / sys 1 is exit
	rts	pc                  / in case exit returns

	.data
outtext: <Hello world!\n>
outlen = . - outtext

Pebble

;Hello world example program
;for x86 DOS
;compile with Pebble

;compiled com program is 51 bytes

program examples\hello

begin

	echo "Hello, world!"
	pause
	kill

end

PepsiScript

The letters are only outputted in uppercase in the running program. However, lowercase characters can be used in the code instead.

For typing:

#include default-libraries

#author Childishbeat

class Hello world/Text:
function Hello world/Text:

print "Hello world!"

end

For importing:

•dl◘Childishbeat◙♦Hello world/Text♪♣Hello_world!♠

Perl

Works with: Perl version 5.8.8
print "Hello world!\n";
Works with: Perl version 5.10.x

Backported from Raku:

use feature 'say';
say 'Hello world!';

or:

use 5.010;
say 'Hello world!';

Peylang

chaap 'Hello world!';
Output:
$ peyman hello.pey
Hello world!

Pharo

"Comments are in double quotes"
"Sending message printString to 'Hello World' string"

'Hello World' printString

Phix

Library: Phix/basics
puts(1,"Hello world!")

PHL

module helloworld;
extern printf;

@Integer main [
    printf("Hello world!");
    return 0;
]

PHP

<?php
echo "Hello world!\n";
?>

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

Hello world!

Picat

println("Hello, world!")

PicoLisp

(prinl "Hello world!")

Pict

Using the syntax sugared version:

(prNL "Hello World!");

Using the channel syntax:

new done: ^[]
run ( prNL!["Hello World!" (rchan done)]
    | done?_ = () )

Pikachu

pikachu pika pikachu pika pika pi pi pika pikachu pika pikachu pi pikachu pi pikachu pi pika pi pikachu pikachu pi pi pika pika pikachu pika pikachu pikachu pi pika pi pika pika pi pikachu pikachu pi pikachu pi pika pikachu pi pikachu pika pikachu pi pikachu pikachu pi pikachu pika pika pikachu pi pikachu pi pi pikachu pikachu pika pikachu pi pika pi pi pika pika pikachu pikachu pi pi pikachu pi pikachu
pikachu pikachu pi pikachu
pikachu pika pika pikachu pika pikachu pikachu pika pika pikachu pikachu pi pi pikachu pika pikachu pika pika pi pika pikachu pikachu pi pika pika pikachu pi pika pi pika pi pikachu pi pikachu pika pika pi pi pika pi pika pika pikachu pikachu pika pikachu pikachu pika pi pikachu pika pi pikachu pi pika pika pi pikachu pika pi pika pikachu pi pi pikachu pika pika pi pika pi pikachu
pikachu pikachu pi pikachu
pikachu pika pi pika pika pikachu pika pikachu pi pikachu pi pi pika pi pikachu pika pi pi pika pikachu pi pikachu pi pi pikachu pikachu pika pikachu pikachu pika pi pikachu pi pika pikachu pi pikachu pika pika pikachu pika pi pi pikachu pikachu pika pika pikachu pi pika pikachu pikachu pi pika pikachu pikachu pika pi pi pikachu pikachu pi pikachu pi pikachu pi pikachu pi pika pikachu pi pikachu pika pikachu pi pika pi pikachu
pi pika
pikachu pikachu pi pikachu
pika pi
pikachu pikachu pi pikachu
pikachu pi pikachu pi pi pikachu pi pikachu pika pikachu pikachu pi pikachu pikachu pika pi pi pika pikachu pika pikachu pi pi pikachu pika pi pi pikachu pika pika pi pika pika pikachu pika pikachu pi pi pika pikachu pika pi pikachu pikachu pi pikachu pika pikachu pikachu pika pi pi pikachu pikachu pi pika pikachu pi pikachu pika pikachu pikachu pika pi pikachu pikachu pika pikachu pi pikachu pika pika pi pikachu pi pika pi pikachu pikachu pi pikachu
pi pika
pikachu pikachu pi pikachu
pikachu pikachu pi pika pikachu pi pika pika pi pi pika pi pikachu pi pika pi pika pi pika pikachu pika pi pi pikachu pi pikachu pi pika pi pika pika pikachu pi pikachu
pikachu pikachu pi pikachu
pikachu pi pikachu pika pikachu pi pika pi pikachu pikachu pika pika pi pi pikachu pi pika pi pikachu pi pika pikachu pi pika pi pi pikachu pikachu pika pika pikachu pikachu pi pi pikachu pi pikachu pi pikachu pi pi pikachu pikachu pi pikachu pi pikachu pi pika pika pikachu pikachu pika pi pika pikachu pi pikachu pi pi pika pikachu pika pi pikachu pi pika pi pi pikachu pikachu pika pika pikachu pika pika pikachu pi pika pi pika pikachu pi pika pikachu pika pi pika pikachu
pikachu pikachu pika pikachu
pikachu pikachu pika pikachu
pi pi pikachu pi pikachu pika pika pi pikachu pika pika pi pi pika pika pikachu pi pi pikachu pi pika pi pika pikachu pi pikachu pi pikachu pikachu pi pi pika pika pi pika pika pi pika pikachu pikachu pi pikachu pika pi pi pika pi pi pikachu pikachu pika pi pi pika pika pi pika pikachu pi pikachu pi pi pika pi pika pika pikachu pika pi pika pikachu pi pikachu pikachu pi pi pika pi pika pika pikachu pikachu pi pikachu
pikachu pikachu pi pikachu
pikachu pi pikachu pikachu pika pikachu pikachu pika pika pikachu pikachu pika pikachu pi pika pikachu pika pika pi pikachu pi pi pika pi pi pikachu pika pika pikachu pikachu pika pikachu pikachu pi pika pi pi pikachu pikachu pika pi pi pikachu pikachu pika pikachu pika pi pikachu pi pika pi pika pikachu pika pi pikachu pi pikachu pikachu pi pika pikachu pi pikachu pikachu pi pika pi pikachu pikachu pi pikachu pika pika pi pi pikachu
pikachu pi pi pika pi pi pikachu pika pikachu pikachu pika pika pi pi pika pikachu pi pikachu pi pi pika pi pika pi pi pika pikachu pi pika pi pikachu pika pikachu pika pi pi pika pi pi pikachu pi pikachu pikachu pika pi pikachu pi pi pika pi pikachu pi pi pika pi pi pikachu pika pikachu pika pikachu pika pi pikachu pikachu pi pi pika pika pikachu
pikachu pikachu pi pikachu
pikachu pikachu pika pikachu

Pike

int main(){
   write("Hello world!\n");
}

PILOT

T:Hello world!

PIR

.sub hello_world_text :main
	print "Hello world!\n"
.end

Pixilang

fputs("Hello world!\n")

PL/I

goodbye:proc options(main);
     put list('Hello world!');
end goodbye;

PL/M

The original PL/M compiler does not recognise lower-case letters, hence the Hello, World! string must specify the ASCII codes for the lower-case letters.

100H:
   /* CP/M BDOS SYSTEM CALL */
   BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
   /* PRINT A $ TERMINATED STRING */
   PRINT$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END;
   /* HELLO, WORLD! IN MIXED CASE */
   DECLARE HELLO$WORLD ( 14 ) BYTE
           INITIAL( 'H', 65H, 6CH, 6CH, 6FH, ',', ' '
                  , 'W', 6FH, 72H, 6CH, 64H, 21H, '$'
                  );
   CALL PRINT$STRING( .HELLO$WORLD );
EOF

PL/SQL

Works with: Oracle
set serveroutput on

BEGIN
  DBMS_OUTPUT.PUT_LINE('Hello world!');
END;
/
SQL> set serveroutput on
SQL> 
SQL> BEGIN
  2    DBMS_OUTPUT.PUT_LINE('Hello world!');
  3  END;
  4  /
Hello world!                                                                    

PL/SQL procedure successfully completed.

Plain English

\This prints Hello World within the CAL-4700 IDE.
\...and backslashes are comments!
To run:
Start up.
Write "Hello World!" to the console.
Wait for the escape key.
Shut down.

Plan

This prints HELLO WORLD on operator's console.

#STEER         LIST,BINARY
#PROGRAM       HLWD
#LOWER
MSG1A          11HHELLO WORLD
MSG1B          11/MSG1A
#PROGRAM
#ENTRY         0
      DISTY    MSG1B
      SUSWT    2HHH
#END
#FINISH
#STOP

Pointless

output = println("Hello world!")

Pony

actor Main
  new create(env: Env) =>
    env.out.print("Hello world!")

Pop11

printf('Hello world!\n');

Portugol

Portugol keywords are Portuguese words.

programa {
// funcao defines a new function
// inicio is the entry point of the program, like main in C
    funcao inicio() {
        // escreva is used to print stuff to the screen
        escreva("Hello, world!\n") // no ';' needed
    }
}

PostScript

To generate a document that shows the text "Hello world!":

%!PS
/Helvetica 20 selectfont
70 700 moveto
(Hello world!) show
showpage

If the viewer has a console, then there are the following ways to display the topmost element of the stack:

(Hello world!) ==

will display the string "(Hello world!)";

(Hello world!) =

will display the content of the string "(Hello world!)"; that is, "Hello world!";

(Hello world!) print

will do the same, without printing a newline. It may be necessary to provoke an error message to make the console pop up. The following program combines all four above variants:

%!PS
/Helvetica 20 selectfont
70 700 moveto
(Hello world!) dup dup dup
= print == % prints three times to the console
show % prints to document
1 0 div % provokes error message
showpage

Potion

"Hello world!\n" print

PowerBASIC

#COMPILE EXE
#COMPILER PBCC 6

FUNCTION PBMAIN () AS LONG
  CON.PRINT "Hello world!"
  CON.WAITKEY$
END FUNCTION

PowerShell

This example used to say that using Write-Host was good practice. This is not true - it should in fact be avoided in most cases.

See http://www.jsnover.com/blog/2013/12/07/write-host-considered-harmful/ (Jeffrey Snover is one of the creators of PowerShell).

'Hello world!'

Processing

println("Hello world!");

ProDOS

printline Hello world!

Programming Language

For typing:

print(Hello world!)

For importing:

[print(Hello world!)]

ProgressBASIC

10 PRINT "Hello world"

Prolog

:- write('Hello world!'), nl.

PROMAL

program hello
include library
begin
output "Hello world!"
end

PSQL

 EXECUTE BLOCK
   RETURNS(S VARCHAR(40))
 AS
 BEGIN
   S = 'Hello world!';
   SUSPEND;
 END

Pure

using system;

puts "Hello world!\n" ;

PureBasic

OpenConsole()
PrintN("Hello world!")
Input() ; Wait for enter

using Debug

Debug("Hello world!")

Python

Works with: Python version 2.4
print "Hello world!"

The same using sys.stdout

import sys
sys.stdout.write("Hello 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("Hello world!")

An easter egg The first two examples print Hello, world! once, and the last one prints it twice.

import __hello__
import __phello__
import __phello__.spam

QB64

PRINT "Hello world!"

Quackery

say "Hello world!"

Quill

"Hello world!" print

Quite BASIC

10 print "Hello world!"

R

 cat("Hello world!\n")

or

 message("Hello world!")

or

 print("Hello world!")

Ra

class HelloWorld
	**Prints "Hello world!"**

	on start

		print "Hello world!"

Racket

(printf "Hello world!\n")

Raku

(formerly Perl 6)

say 'Hello world!';

In an object-oriented approach, the string is treated as an object calling its say() method:

"Hello, World!".say();

Raven

'Hello world!' print

RATFOR

program hello

write(*,101)"Hello World"
101 format(A)

end


RASEL

A"!dlroW ,olleH">:?@,Hj

REALbasic

Works with: REALbasic version 5.5

This requires a console application.

Function Run(args() as String) As Integer
  Print "Hello world!"
  Quit
End Function

REBOL

print "Hello world!"

RED

print "Hello world!"

Refal

$ENTRY Go {
    = <Prout 'Hello, world!'>;
};

Relation

' Hello world!

ReScript

Js.log("Hello world!")
Output:
$ bsc hello.res > hello.bs.js
$ node hello.bs.js
Hello world!

Retro

'Hello_world! s:put

REXX

using SAY

/*REXX program to show a line of text.  */
say 'Hello world!'

using SAY variable

/*REXX program to show a line of text.  */
yyy = 'Hello world!'
say yyy

using LINEOUT

/*REXX program to show a line of text.  */

call lineout ,"Hello world!"

Rhovas

print("Hello world!");

Ring

See "Hello world!"

RISC-V Assembly

.data
hello:
.string "Hello World!\n\0"
.text
main:
la a0, hello
li a7, 4
ecall
li a7, 10
ecall

Roc

app "hello"
    packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.1.1/zAoiC9xtQPHywYk350_b7ust04BmWLW00sjb9ZPtSQk.tar.br" }
    imports [pf.Stdout]
    provides [main] to pf

main =
    Stdout.line "I'm a Roc application!"

Rockstar

Shout "Hello world!"

RPG

**free
dsply 'Hello World!';

RPL

≪ "Hello world!" 1 DISP 
   1 FREEZE                 @ remove this line on HP-28 models
≫ 'TASK' STO

RTL/2

TITLE Goodbye World;

LET NL=10;

EXT PROC(REF ARRAY BYTE) TWRT;

ENT PROC INT RRJOB();

    TWRT("Hello world!#NL#");
    RETURN(1);

ENDPROC;

Ruby

Works with: Ruby version 1.8.4
puts "Hello world!"

or

$stdout.puts "Hello world!"

or even

 STDOUT.write "Hello world!\n"


Using the > global

$>.puts "Hello world!"
$>.write "Hello world!\n"

Run BASIC

print "Hello world!"

Rust

fn main() {
   print!("Hello world!");
}

or

fn main() {
   println!("Hello world!");
}

Salmon

"Hello world!"!

or

print("Hello world!\n");

or

standard_output.print("Hello world!\n");

SAS

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

SASL

Note that a string starts with a single and ends with a double quote

'Hello World!",nl

Sather

class GOODBYE_WORLD is
 main is 
  #OUT+"Hello world!\n"; 
 end; 
end;

Scala

Library: Console

Ad hoc REPL solution

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

println("Hello world!")

Via Java runtime

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

System.out.println("Hello world!")

Via Scala Console API

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

println("Hello 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

All Scheme implementations display the value of the last evaluated expression before the program terminates.

"Hello world!"

The display and newline procedures are found in specific modules of the standard library in R6RS and R7RS. The previous standards have no concept of modules and the entirety of the standard library is loaded by default.

R5RS

(display "Hello world!")
(newline)

R6RS

(import (rnrs base (6))
        (rnrs io simple (6)))
(display "Hello world!")
(newline)

R7RS

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

Scilab

disp("Hello world!");

ScratchScript

print "Hello world!"

This example waits until the mouse is clicked for the program to end. This can be useful if the program executes too fast for "Hello world!" to be visible on the screen long enough for it to be comfortable.

print "Hello world!"
delayOnClick

sed

i\
Hello world!
q

Seed7

$ include "seed7_05.s7i";

const proc: main is func
  begin
    writeln("Hello world!");
  end func;

Self

'Hello world!' printLine.

SenseTalk

put "Hello world!"

Set lang

set ! H
set ! E
set ! L
set ! L
set ! O
set ! 32
set ! W
set ! O
set ! R
set ! L
set ! D
set ! 33

SETL

print("Hello world!");

SETL4

out("Hello world!");end

Shen

(output "Hello world!~%")

Shiny

say 'Hello world!'

Sidef

„Hello world!”.say;

SimpleCode

The letters are only outputted in uppercase in the running program. However, lowercase characters can be used in the code instead.

dtxt
Hello world!

SIMPOL

function main()
end function "Hello world!{d}{a}"

Simula

Works with: SIMULA-67
BEGIN
   OUTTEXT("Hello world!");
   OUTIMAGE
END

Sing

requires "sio";

public fn singmain(argv [*]string) i32
{
    sio.print("hello world !\r\n");
    return(0);
}

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)
  "Hello world!"
end function

Skew

Works with: skewc version 0.9.19
@entry
def main {
  dynamic.console.log("Hello world!")
}

SkookumScript

print("Hello world!")

Alternatively if just typing in the SkookumIDE REPL:

"Hello world!"

Slate

inform: 'Hello world!'.

Slope

(write "Hello, world!")

SmallBASIC

PRINT "Hello world!"

Smalltalk

Transcript show: 'Hello world!'; cr.
Works with: GNU Smalltalk

(as does the above code)

'Hello world!' printNl.

smart BASIC

PRINT "Hello world!"

SmileBASIC

PRINT "Hello world!"

SNOBOL4

Using CSnobol4 dialect

    OUTPUT = "Hello world!"
END

SNUSP

Core SNUSP

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

Modular SNUSP

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

Soda

class Main

  main (arguments : Array [String] ) : Unit =
    println ("Hello world!")

end

SoneKing Assembly

extern print

dv Msg Goodbye,World!

mov eax Msg
push
call print
pop

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	"Hello world!\n"
.msgend:

Sparkling

print("Hello world!");

SPL

#.output("Hello world!")

SQL

Works with: Oracle
Works with: Db2 LUW
select 'Hello world!' text from dual;
SQL>select 'Hello world!' text from dual;
TEXT
------------
Hello world!

SQL PL

Works with: Db2 LUW

With SQL only:

SELECT 'Hello world!' AS text FROM sysibm.sysdummy1;

Output:

db2 -t
db2 => SELECT 'Hello world!' AS text FROM sysibm.sysdummy1;

TEXT        
------------
Hello world!

  1 record(s) selected.
Works with: Db2 LUW

version 9.7 or higher.

With SQL PL:

SET SERVEROUTPUT ON;

CALL DBMS_OUTPUT.PUT_LINE('Hello world!');

Output:

db2 -t
db2 => SET SERVEROUTPUT ON
DB20000I  The SET SERVEROUTPUT command completed successfully.
db2 => CALL DBMS_OUTPUT.PUT_LINE('Hello world!')

  Return Status = 0

Hello world!

Standard ML

print "Hello world!\n"

Stata

display "Hello world!"

Suneido

Print("Hello world!")

Swahili

andika("Hello world!")

Swift

Works with: Swift version 2.x+
print("Hello world!")
Works with: Swift version 1.x
println("Hello world!")

Symstatic

println("Hello world!")

Symsyn

 'hello world' []

TailDot

c,x,Hello World!,v,x

Tailspin

'Hello World' -> !OUT::write

Tcl

Output to terminal:

puts stdout {Hello world!}

Output to arbitrary open, writable file:

puts $fileID {Hello world!}

Teco

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

^AHello world!^A$$

Tern

println("Hello world!");

Terra

C = terralib.includec("stdio.h")

terra hello(argc : int, argv : &rawstring)
  C.printf("Hello world!\n")
  return 0
end

Terraform

output "result" {
  value = "Hello world!"
}
Output:
$ terraform init
$ terraform apply

Apply complete! Resources: 0 added, 0 changed, 0 destroyed.

Outputs:

result = Hello world!
$ terraform output result
Hello world!

TestML

%TestML 0.1.0
Print("Hello world!")

TI-57

0.7745

You must then turn the calculator upside down to read the text: screenshot

TI-83 BASIC

Disp "Hello world!

(Lowercase letters DO exist in TI-BASIC, though you need an assembly program to enable them.)

TI-89 BASIC

Disp "Hello world!"

Tiny BASIC

Works with: TinyBasic
10 PRINT "Hello, World!"
20 END

TMG

Unix TMG:

begin: parse(( = { <Hello, World!> * } ));

TorqueScript

echo("Hello world!");

TPP

Hello world!

Transact-SQL

PRINT "Hello world!"

Transd

(textout "Hello, World!")

TransFORTH

PRINT " Hello world! "

Trith

"Hello world!" print

True BASIC

! In True BASIC all programs run in their own window. So this is almost a graphical version.
PRINT "Hello world!"
END

TUSCRIPT

$$ MODE TUSCRIPT
PRINT "Hello world!"

Output:

Hello world!

uBasic/4tH

Print "Hello world!"

Uniface

message "Hello world!"

Unison

main = '(printLine "Hello world!")

UNIX Shell

Works with: Bourne Shell
#!/bin/sh
echo "Hello world!"

C Shell

#!/bin/csh -f
echo "Hello 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

Ursa

out "hello world!" endl console

Ursala

output as a side effect of compilation

#show+

main = -[Hello world!]-

output by a compiled executable

#import std

#executable ('parameterized','')

main = <file[contents: -[Hello world!]-]>!

Ursalang

print("hello woods!")

உயிர்/Uyir

முதன்மை என்பதின் வகை எண் பணி {{
         ("உலகத்தோருக்கு வணக்கம்") என்பதை திரை.இடு;

         முதன்மை = 0;
}};

Uxntal

( hello-world.tal )
|00 @System  [ &vector $2 &wst  $1 &rst $1 &eaddr $2 &ecode $1 &pad $1 &r $2 &g $2 &b $2 &debug $1 &halt $1 ]
|10 @Console [ &vector $2 &read $1 &pad $5 &write $1 &error $1 ]

( program )
|0100 @on-reset ( -> )
    ;hello print-str
    HALT
BRK

@print-str ( str* -- )
    &while
        LDAk .Console/write DEO
        INC2 LDAk ?&while
    POP2
JMP2r

@HALT ( -- )
    #01 .System/halt DEO
JMP2r

@hello "Hello 20 "world! 0a 00

V

"Hello world!" puts

Vala

void main(){
	stdout.printf("Hello world!\n");
}

Vale

Works with: Vale version 0.2.0
import stdlib.*;

exported func main() {
	println("Hello world!");
}

VAX Assembly

desc:  .ascid "Hello World!"      ;descriptor (len+addr) and text
.entry hello, ^m<>                ;register save mask
       pushaq desc                ;address of descriptor
       calls #1, g^lib$put_output ;call with one argument on stack
       ret                        ;restore registers, clean stack & return
.end hello                        ;transfer address for linker

VBA

Public Sub hello_world_text
    Debug.Print "Hello World!"
End Sub


VBScript

Works with: Windows Script Host version 5.7
WScript.Echo "Hello world!"

Vedit macro language

Message("Hello world!")

Verbexx

@SAY "Hello world!";


Verilog

module main;
  initial begin
      $display("Hello world!");
      $finish ;
    end
endmodule

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'("Hello world!"));
    writeline(OUTPUT, line_out);
    wait; -- needed to stop the execution
  end process;
end architecture beh;

Vim Script

echo "Hello world!\n"

Visual Basic

Works with: Visual Basic version VB6 Standard

Visual Basic 6 is actually designed to create GUI applications, however with a little help from the Microsoft.Scripting Library it is fairly easy to write a simple console application.

Option Explicit

Private Declare Function AllocConsole Lib "kernel32.dll" () As Long
Private Declare Function FreeConsole Lib "kernel32.dll" () As Long
'needs a reference set to "Microsoft Scripting Runtime" (scrrun.dll)

Sub Main()
  Call AllocConsole
  Dim mFSO As Scripting.FileSystemObject
  Dim mStdIn As Scripting.TextStream
  Dim mStdOut As Scripting.TextStream
  Set mFSO = New Scripting.FileSystemObject
  Set mStdIn = mFSO.GetStandardStream(StdIn)
  Set mStdOut = mFSO.GetStandardStream(StdOut)
  mStdOut.Write "Hello world!" & vbNewLine
  mStdOut.Write "press enter to quit program."
  mStdIn.Read 1
  Call FreeConsole
End Sub

Visual Basic .NET

Imports System

Module HelloWorld
    Sub Main()
        Console.WriteLine("Hello world!")
    End Sub
End Module

Viua VM assembly

.function: main/0
    text %1 local "Hello World!"
    print %1 local
    izero %0 local
    return
.end

V (Vlang)

println('Hello World!')

VTL-2

10 ?="Hello world!"

Waduzitdo

T:Hello world!
S:

Wart

prn "Hello world!"

WDTE

io.writeln io.stdout 'Hello world!';

WebAssembly

Library: WASI
(module $helloworld

    ;;Import fd_write from WASI, declaring that it takes 4 i32 inputs and returns 1 i32 value
    (import "wasi_unstable" "fd_write"
        (func $fd_write (param i32 i32 i32 i32) (result i32))
    )

    ;;Declare initial memory size of 32 bytes
    (memory 32)

    ;;Export memory so external functions can see it
    (export "memory" (memory 0))
 
    ;;Declare test data starting at address 8
    (data (i32.const 8) "Hello world!\n")
 
    ;;The entry point for WASI is called _start
    (func $main (export "_start")
        
        ;;Write the start address of the string to address 0
        (i32.store (i32.const 0) (i32.const 8)) 
 
        ;;Write the length of the string to address 4
        (i32.store (i32.const 4) (i32.const 13))

        ;;Call fd_write to print to console
        (call $fd_write
            (i32.const 1) ;;Value of 1 corresponds to stdout
            (i32.const 0) ;;The location in memory of the string pointer
            (i32.const 1) ;;Number of strings to output
            (i32.const 24) ;;Address to write number of bytes written
        )
        drop ;;Ignore return code
    )
)

Wee Basic

print 1 "Hello world!"
end

Whenever

1 print("Hello world!");

Whiley

import whiley.lang.System

method main(System.Console console):
    console.out.println("Hello world!")

Whitespace

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

Wisp

Output in Wisp follows the same concepts as Scheme, but replacing outer parentheses with indentation.

With Guile and wisp installed, this example can be tested in a REPL started with guile --language=wisp, or directly with the command wisp.

import : scheme base
         scheme write
display "Hello world!"
newline

Wolfram Language

Print["Hello world!"]

Wren

System.print("Hello world!")

X10

class HelloWorld {
  public static def main(args:Rail[String]):void {
    if (args.size < 1) {
        Console.OUT.println("Hello world!");
        return;
    }
  }
}

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 "Hello world!" to stdout (and there is probably an even simpler version):

section .data
msg     db      'Hello 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

AT&T syntax: works with gcc (version 4.9.2) and gas (version 2.5):

.section .text

.globl main

main:
	movl $4,%eax	#syscall number 4
	movl $1,%ebx	#number 1 for stdout
	movl $str,%ecx	#string pointer
	movl $16,%edx	#number of bytes
	int $0x80	#syscall interrupt
	ret

.section .data
str: .ascii "Hello world!\12"

X86-64 Assembly

UASM

option casemap:none
if @Platform eq 1
   option dllimport:<kernel32>
      ExitProcess   proto :dword
   option dllimport:none
      exit          equ ExitProcess
endif
printf              proto :qword, :vararg
exit                proto :dword

.code
main proc
invoke printf, CSTR("Goodbye, World!",10)
invoke exit, 0
ret
main endp
end

AT&T syntax (Gas)

// No "main" used
// compile with `gcc -nostdlib`
#define SYS_WRITE   $1
#define STDOUT      $1
#define SYS_EXIT    $60
#define MSGLEN      $14

.global _start
.text

_start:
    movq    $message, %rsi          // char *
    movq    SYS_WRITE, %rax
    movq    STDOUT, %rdi
    movq    MSGLEN, %rdx
    syscall                         // sys_write(message, stdout, 0x14);
    
    movq    SYS_EXIT, %rax
    xorq    %rdi, %rdi              // The exit code.
    syscall                         // exit(0)
    
.data
message:    .ascii "Hello, world!\n"

XBasic

Works with: Windows XBasic
PROGRAM "hello"
VERSION "0.0003"

DECLARE FUNCTION Entry()

FUNCTION Entry()
  PRINT "Hello World"
END FUNCTION
END PROGRAM

xEec

h#10 h$! h$d h$l h$r h$o h$w h#32  
h$o h$l h$l h$e h$H >o o$ p jno

XL

use XL.UI.CONSOLE
WriteLn "Hello world!"

XLISP

(DISPLAY "Hello world!")
(NEWLINE)

XPL0

code Text=12;
Text(0, "Hello world!
")

XPath

'Hello world&#xA;'

XSLT

With a literal newline:

<xsl:text>Hello world!
</xsl:text>

Or, with an explicit newline:

<xsl:text>Hello world!&#xA;</xsl:text>

Yabasic

print "Hello world!"

YAMLScript

All the following examples are valid YAML and valid YAMLScript.

This is a good example of various ways to write function calls in YAMLScript.

Since function calls must fit into their YAML context, which may be mappings or scalars; it is actually useful to support these variants.

!yamlscript/v0

say: "Hello, world!"

=>: (say "Hello, world!")

=>: say("Hello, world!")

say:
  =>: "Hello, world!"

say: ("Hello, " + "world!")

say: ."Hello," "world!"

say "Hello,": "world!"

say "Hello," "world!":

Yorick

write, "Hello 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	"Hello world!\r\n\0"

zkl

println("Hello world!");

Zig

Works with: 0.10.x, 0.11.x, 0.12.0-dev.1389+42d4d07ef

const std = @import("std");

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

    try stdout.writeAll("Hello world!\n");
}

Zoea

program: hello_world 
  output: "Hello  world!"

Zoea Visual

Hello World

Zoomscript

For typing:

print "Hello world!"

For importing:

¶0¶print "Hello world!"

ZX Spectrum Basic

10 print "Hello world!"