Hello world/Text: Difference between revisions
No edit summary |
|||
Line 1:
{{task|Basic language learning}}
{{selection|Short Circuit|Console Program Basics}}
[[Category:Simple]]
;Task:
Display the string '''Hello world!''' on a text console.
;Related tasks:
* [[Hello world/
* [[Hello world/
* [[Hello world/Newbie]]
* [[Hello world/Newline omission]]
* [[Hello world/Standard error]]
* [[Hello world/Web server]]
<br><br>
=={{header|0815}}==
<syntaxhighlight lang="0815">
<:48:x<:65:=<:6C:$=$=$$~<:03:+
$~<:ffffffffffffffb1:+$<:77:~$
~<:fffffffffffff8:x+$~<:03:+$~
<:06:x-$x<:0e:x-$=x<:43:x-$
</syntaxhighlight>
=={{header|11l}}==
<syntaxhighlight lang="11l">print(‘Hello world!’)</syntaxhighlight>
=={{header|360 Assembly}}==
Using native SVC (Supervisor Call) to write to system console:
<syntaxhighlight lang="360 assembly">
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</syntaxhighlight>
Using WTO Macro to generate SVC 35 and message area:
<syntaxhighlight lang="360 assembly"> WTO 'Hello world!'
BR 14 Return
END
</syntaxhighlight>
=={{header|IBM Z HL/ASM}}==
Using Modern IBM Z High Level assembler to write 'Hello World' to the Unix System Services 'stdout' file descriptor
<syntaxhighlight lang="360 assembly">
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
</syntaxhighlight>
=={{header|IBM Z HL/ASM}}==
Using Modern IBM Z High Level assembler to write 'Hello World' to the Unix System Services 'stdout' file descriptor
<syntaxhighlight lang="360 assembly">
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
</syntaxhighlight>
=={{header|4DOS Batch}}==
<syntaxhighlight lang
=={{header|4ME}}==
P:hw
out{Hello world}
=={{header|6502 Assembly}}==
<
; String printing limited to strings of 256 characters or less.
a_cr = $0d ; Carriage return.
bsout = $ffd2 ;
; use $fded for Apple 2, $ffe3 (ascii) or $ffee (raw) for BBC.
.code
Line 33 ⟶ 346:
text:
.byte "Hello
=={{header|6800 Assembly}}==
<syntaxhighlight lang="text"> .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</syntaxhighlight>
=={{header|8080 Assembly}}==
<syntaxhighlight lang="8080asm"> ; 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!$'</syntaxhighlight>
=={{header|8086 Assembly}}==
<syntaxhighlight lang="masm">DOSSEG
.MODEL TINY
.DATA
TXT DB "
.CODE
START:
Line 45 ⟶ 406:
MOV ds, ax
MOV ah, 09h ; prepare output function
MOV dx, OFFSET TXT ; set offset
INT 21h ; output string TXT
Line 51 ⟶ 412:
MOV AX, 4C00h ; go back to DOS
INT 21h
END START</
With A86 or NASM syntax:
<pre> org 100h
mov dx, msg
mov ah, 9
int 21h
mov ax, 4c00h
int 21h
msg:
db "Hello world!$"</pre>
=={{header|8th}}==
<syntaxhighlight lang="forth">"Hello world!\n" . bye</syntaxhighlight>
=={{header|AArch64 Assembly}}==
<syntaxhighlight lang="arm_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</syntaxhighlight>
=={{header|ABAP}}==
<
WRITE '
=={{header|ACL2}}==
<syntaxhighlight lang="lisp">(cw "Hello world!~%")</syntaxhighlight>
=={{header|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 <code>printc</code>, will not.
<syntaxhighlight lang="lisp">(printc 'Hello! world!!)</syntaxhighlight>
The single quote in front of <code>Hello! world!!</code> 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.
=={{header|Action!}}==
<syntaxhighlight lang="action!">Proc Main()
Print("Hello world!")
Return</syntaxhighlight>
=={{header|ActionScript}}==
<
=={{header|Ada}}==
{{works with|GCC|4.1.2}}
<
procedure Main is
begin
Put_Line ("
end Main;</
=={{header|
For Agda 2.6.3, based on its [https://agda.readthedocs.io/en/v2.6.3/getting-started/hello-world.html documentation].
<syntaxhighlight lang="agda">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!"
</syntaxhighlight>
=={{header|Agena}}==
<syntaxhighlight lang="agena">print( "Hello world!" )</syntaxhighlight>
=={{header|Aime}}==
<syntaxhighlight lang="aime">o_text("Hello world!\n");</syntaxhighlight>
or:
<syntaxhighlight lang="aime">integer
main(void)
{
o_text("Hello world!\n");
return 0;
}</syntaxhighlight>
=={{header|Algae}}==
<
=={{header|ALGOL 60}}==
<syntaxhighlight lang="algol60">'BEGIN'
OUTSTRING(1,'('Hello world!')');
SYSACT(1,14,1)
'END'</syntaxhighlight>
=={{header|ALGOL 68}}==
<
printf($"
)</
=={{header|ALGOL W}}==
<syntaxhighlight lang="algolw">begin
write( "Hello world!" )
end.</syntaxhighlight>
=={{header|ALGOL-M}}==
<syntaxhighlight lang="algol">BEGIN
WRITE( "Hello world!" );
END</syntaxhighlight>
=={{header|Alore}}==
<syntaxhighlight lang="alore">Print('Hello world!')</syntaxhighlight>
=={{header|Amazing Hopper}}==
1)
<syntaxhighlight lang="amazing hopper">
main:
{"Hello world!\n"}print
exit(0)
</syntaxhighlight>
<pre>execute with: hopper helloworld.com</pre>
2)
<syntaxhighlight lang="amazing hopper">
#include <hopper.h>
main:
exit("Hello world!\n")
</syntaxhighlight>
<pre>execute with: hopper helloworld.com -d</pre>
3)
<syntaxhighlight lang="amazing hopper">
main:
{"Hello world!\n"}return
</syntaxhighlight>
<pre>execute with: hopper helloworld.com -d</pre>
=={{header|AmbientTalk}}==
<syntaxhighlight lang="ambienttalk">system.println("Hello world!")</syntaxhighlight>
=={{header|AmigaE}}==
<
WriteF('
ENDPROC</
=={{header|AngelScript}}==
<syntaxhighlight lang="angelscript">void main() { print("Hello world\n"); }</syntaxhighlight>
=={{header|AntLang}}==
Note, that "Hello, World!" prints twice in interactive mode.
One time as side-effect and one as the return value of echo.
<syntaxhighlight lang="antlang">echo["Hello, World!"]</syntaxhighlight>
=={{header|Anyways}}==
<syntaxhighlight lang="anyways">There was a guy called Hello World
"Ow!" it said.
That's all folks!</syntaxhighlight>
=={{header|APL}}==
<syntaxhighlight lang="apl">'Hello world!'</syntaxhighlight>
=={{header|AppleScript}}==
To show in Script Editor Result pane:
<
To show in Script Editor Event Log pane:
<
=={{header|Applesoft BASIC}}==
<!-- {{incorrect|Applesoft BASIC|output isn't consistent with the task's requirements: mixed case.}} -->
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.
<syntaxhighlight lang="applesoft basic"> PRINT "Hello world!"</syntaxhighlight>
=={{header|Apricot}}==
<syntaxhighlight lang="apricot">(puts "Hello world!")</syntaxhighlight>
=={{header|Arc}}==
<syntaxhighlight lang="arc">(prn "Hello world!")</syntaxhighlight>
=={{header|Arendelle}}==
<pre>"Hello world!"</pre>
=={{header|Argile}}==
<
print "
compile with: arc hello_world.arg -o hello_world.c && gcc -o hello_world hello_world.c
=={{header|ARM Assembly}}==
<syntaxhighlight lang="arm_assembly">.global main
message:
.asciz "Hello world!\n"
.align 4
main:
ldr r0, =message
bl printf
mov r7, #1
swi 0</syntaxhighlight>
Alternative versions
<pre>
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
</pre>
=={{header|ArnoldC}}==
<syntaxhighlight lang="arnoldc">IT'S SHOWTIME
TALK TO THE HAND "Hello world!"
YOU HAVE BEEN TERMINATED</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">print "Hello world!"</syntaxhighlight>
{{out}}
<pre>Hello world!</pre>
=={{header|AsciiDots}}==
<syntaxhighlight lang="asciidots">
.-$'Hello, World!'
</syntaxhighlight>
=={{header|Astro}}==
<syntaxhighlight lang="python">print "Hello world!"</syntaxhighlight>
=={{header|Asymptote}}==
<syntaxhighlight lang="asymptote">write('Hello world!');</syntaxhighlight>
=={{header|Atari BASIC}}==
<syntaxhighlight lang="Atari BASIC">10 PRINT "Hello World"</syntaxhighlight>
=={{header|ATS}}==
<syntaxhighlight lang="ats">implement main0 () = print "Hello world!\n"</syntaxhighlight>
=={{header|AutoHotkey}}==
script launched from windows explorer
<
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]
<
FileAppend, Goodbye`, World!, CONOUT$</
<
=={{header|AutoIt}}==
<syntaxhighlight lang="autoit">ConsoleWrite("Hello world!" & @CRLF)</syntaxhighlight>
=={{header|AutoLISP}}==
<syntaxhighlight lang="cadlisp">(printc "Hello World!")</syntaxhighlight>
=={{header|Avail}}==
<syntaxhighlight lang="avail">Print: "Hello World!";</syntaxhighlight>
=={{header|AWK}}==
<
"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.
<syntaxhighlight lang="awk">
END {
print "Hello world!"
}
</syntaxhighlight>
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.
<syntaxhighlight lang="awk">
// {
print "Hello world!"
exit
}
</syntaxhighlight>
For a "single record" file.
<syntaxhighlight lang="awk">
// {
print "Hello world!"
}
</syntaxhighlight>
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.
<syntaxhighlight lang="awk">
//
</syntaxhighlight>
=={{header|Axe}}==
Note that the i here is the imaginary ''i'', not the lowercase letter i.
<syntaxhighlight lang="axe">Disp "Hello world!",i</syntaxhighlight>
=={{header|B}}==
{{works with|The Amsterdam Compiler Kit - B|V6.1pre1}}
<syntaxhighlight lang="b">main()
{
putstr("Hello world!*n");
return(0);
}</syntaxhighlight>
=={{header|B4X}}==
<syntaxhighlight lang="b4x">Log("Hello world!")</syntaxhighlight>
=={{header|Babel}}==
<syntaxhighlight lang="babel">"Hello world!" <<</syntaxhighlight>
=={{header|BabyCobol}}==
<syntaxhighlight lang="cobol">
* 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.
</syntaxhighlight>
=={{header|Bait}}==
<syntaxhighlight lang="bait">fun main() {
println('Hello World!')
}</syntaxhighlight>
=={{header|Ballerina}}==
<syntaxhighlight lang="ballerina">import ballerina/io;
public function main() {
io:println("Hello World!");
}</syntaxhighlight>
=={{header|bash}}==
<syntaxhighlight lang="bash">echo "Hello world!"</syntaxhighlight>
=={{header|BASIC}}==
{{works with|BASICA}}
{{works with|Chipmunk Basic}}
{{works with|
{{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}}
<syntaxhighlight lang="qbasic">10 print "Hello world!"</syntaxhighlight>
{{works with|7Basic}}
{{works with|Applesoft BASIC}}
{{works with|BaCon}} [[Category: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}}
<syntaxhighlight lang="qbasic">PRINT "Hello world!"</syntaxhighlight>
=={{header|BASIC256}}==
<syntaxhighlight lang="basic256">PRINT "Hello world!"</syntaxhighlight>
=={{header|Batch File}}==
'''Under normal circumstances, when delayed expansion is disabled'''
<syntaxhighlight lang="dos">echo Hello world!</syntaxhighlight>
'''If delayed expansion is enabled, then the ! must be escaped twice'''
<syntaxhighlight lang="dos">setlocal enableDelayedExpansion
echo Hello world!^^!</syntaxhighlight>
=={{header|Battlestar}}==
<!--- supports C syntax highlighting --->
<syntaxhighlight lang="c">const hello = "Hello world!\n"
print(hello)</syntaxhighlight>
=={{header|BBC BASIC}}==
<syntaxhighlight lang="bbcbasic"> PRINT "Hello world!"</syntaxhighlight>
=={{header|bc}}==
<syntaxhighlight lang="bc">"Hello world!
"</syntaxhighlight>
=={{header|BCPL}}==
<
LET start() = VALOF
{ writef("
RESULTIS 0
}</
=={{header|Beef}}==
<syntaxhighlight lang=csharp>Using System;
namespace HelloWorld {
class Program
{
static void Main()
{
Console.Writeln("Hello World!");
}
}
}
</syntaxhighlight>
=={{header|beeswax}}==
Straightforward:
<syntaxhighlight lang="beeswax">*`Hello, World!</syntaxhighlight>
Less obvious way:
<syntaxhighlight lang="beeswax">>`ld!
`
r
o
W
`
b` ,olleH`_</syntaxhighlight>
Even less obvious, demonstrating the creation and execution order of instruction pointers, and the hexagonal layout of beeswax programs:
<syntaxhighlight lang="beeswax">r l
l o
``
ol`*`,d!
``
e H
W</syntaxhighlight>
=={{header|Befunge}}==
<
=={{header|Binary Lambda Calculus}}==
As explained at https://www.ioccc.org/2012/tromp/hint.html
<pre> Hello world!</pre>
=={{header|Bird}}==
It's not possible to print exclamation marks in [[Bird]] which is why it is not used in this example.
<syntaxhighlight lang="bird">use Console
define Main
Console.Println "Hello world"
end</syntaxhighlight>
=={{header|Blade}}==
<syntaxhighlight lang="blade">echo 'Hello world!'</syntaxhighlight>
or
<syntaxhighlight lang="blade">print('Hello world!')</syntaxhighlight>
or
<syntaxhighlight lang="blade">import io
io.stdout.write('Hello world!')</syntaxhighlight>
=={{header|Blast}}==
<syntaxhighlight lang="blast"># This will display a goodbye message on the terminal screen
.begin
display "Hello world!"
return
# This is the end of the script.</syntaxhighlight>
=={{Header|BlitzMax}}==
<syntaxhighlight lang="blitzmax">
print "Hello world!"
</syntaxhighlight>
=={{header|Blue}}==
Linux/x86
<syntaxhighlight lang="blue">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 ;</syntaxhighlight>
=={{header|blz}}==
<syntaxhighlight lang="blz">print("Hello world!")</syntaxhighlight>
=={{header|BML}}==
<syntaxhighlight lang="bml">display "Hello world!"</syntaxhighlight>
=={{header|Boo}}==
<syntaxhighlight lang="boo">print "Hello world!"</syntaxhighlight>
=={{header|bootBASIC}}==
<syntaxhighlight lang="BASIC">10 print "Hello world!"</syntaxhighlight>
=={{header|BQN}}==
Works in: [[CBQN]]
<syntaxhighlight lang="bqn">•Out "Hello world!"</syntaxhighlight>
=={{header|Brace}}==
<
use b
Main:
say("
=={{header|Bracmat}}==
<syntaxhighlight lang="bracmat">put$"Hello world!"</syntaxhighlight>
=={{header|Brainf***}}==
To print text, we need the ascii-value of each character to output.<br>
So, we wanna make a series of round numbers going like:
10 close to newline and carriage return
Line 162 ⟶ 1,033:
Commented version:
<
[
Line 220 ⟶ 1,091:
CRLF
< +++ . --- .</
Uncommented:
<
++++++++>+++++++++++>++++++++++++<<<<<<<<<-]>>>>+.>>>
>+..<.<++++++++.>>>+.<<+.<<<<++++.<++.>>>+++++++.>>>.+++.
<+++++++.--------.<<<<<+.<+++.---.</
It can most likely be optimized, but this is a nice way to show
how character printing works in Brainf*** :)
=={{header|Brat}}==
<syntaxhighlight lang="brat">p "Hello world!"</syntaxhighlight>
=={{header|Brlcad}}==
The mged utility can output text to the terminal:
<syntaxhighlight lang="brlcad">
echo Hello world!
</syntaxhighlight>
=={{header|Bruijn}}==
Ignore stdin by not referring to the abstraction:
<syntaxhighlight lang="bruijn">
main ["Hello world!"]
</syntaxhighlight>
=={{header|Burlesque}}==
<syntaxhighlight lang="burlesque">
"Hello world!"sh
</syntaxhighlight>
Although please note that ''sh'' actually does not print anything.
=={{header|C}}==
{{works with|gcc|4.0.1}}
<
#include <stdio.h>
int main(
{
printf("
return EXIT_SUCCESS;
}</syntaxhighlight>
Or:
<syntaxhighlight lang="c">#include <stdlib.h>
#include <stdio.h>
int main(void)
{
puts("Hello world!");
return EXIT_SUCCESS;
}</syntaxhighlight>
Or, the eternal favourite :)
<syntaxhighlight lang="c">
#include<stdio.h>
int main()
{
printf("\nHello world!");
return 0;
}</
or better yet...
<syntaxhighlight lang="c">
#include<stdio.h>
int main()
{
return printf("\nHello World!");
}
</syntaxhighlight>
=={{header|C sharp|C#}}==
{{works with|Mono|1.2}}
{{works with|Visual C sharp|Visual C#|2003}}
<syntaxhighlight lang="csharp">namespace HelloWorld
{
class Program
{
static void Main(string[] args)
{
System.Console.WriteLine("Hello world!");
}
}
}</syntaxhighlight>
{{works with|Visual C sharp|Visual C#|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.
<syntaxhighlight lang="csharp">System.Console.WriteLine("Hello world!");</syntaxhighlight>
or
<syntaxhighlight lang="csharp">using System;
Console.WriteLine("Hello world!");</syntaxhighlight>
=={{header|C++}}==
<
int main
std::cout << "
}</syntaxhighlight>
Since C++23’s addition of the <code><print></code> header and the standard library module <code>std</code> we could now write this:
<syntaxhighlight lang="cpp">import module std; // here does the same thing as #include <print>
int main() {
std::print("Hello world!\n");
}</syntaxhighlight>
=={{header|C++/CLI}}==
<syntaxhighlight lang="cpp">using namespace System;
int main()
{
Console::WriteLine("Hello world!");
}</syntaxhighlight>
=={{header|C1R}}==
<syntaxhighlight lang="c0h">Hello_world/Text</syntaxhighlight>
{{out}}
<pre>
$ echo Hello_world/Text >hw.c1r
$ ./c1r hw.c1r
$ ./a.out
Hello world!
</pre>
=={{header|C2}}==
<syntaxhighlight lang="c2">module hello_world;
import stdio as io;
func i32 main(i32 argc, char** argv) {
io.printf("Hello World!\n");
return 0;
}</syntaxhighlight>
=={{header|C3}}==
<syntaxhighlight lang="c3">import std::io;
fn void main()
{
io::printn("Hello, World!");
}</syntaxhighlight>
=={{header|Casio BASIC}}==
<syntaxhighlight lang="basic casio">Locate 1,1,"Hello World!"</syntaxhighlight>
or just
<syntaxhighlight lang="basic casio">"Hello World!"</syntaxhighlight>
=={{header|Cat}}==
<syntaxhighlight lang="cat">"Hello world!" writeln</syntaxhighlight>
=={{header|Cduce}}==
<syntaxhighlight lang="cduce">print "Hello world!";;</syntaxhighlight>
=={{header|CFEngine}}==
<syntaxhighlight lang="cfengine3">#!/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!";
}</syntaxhighlight>
See https://docs.cfengine.com/docs/master/examples.html for a more complete example and introduction.
=={{header|Chapel}}==
<syntaxhighlight lang="chapel">writeln("Hello world!");</syntaxhighlight>
=={{header|Chef}}==
<syntaxhighlight lang="chef">Goodbye World Souffle.
Ingredients.
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.
Line 282 ⟶ 1,287:
Put water into the mixing bowl.
Put zucchinis into the mixing bowl.
Put
Put eggs into the mixing bowl.
Put
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.</syntaxhighlight>
=={{header|Chipmunk Basic}}==
<syntaxhighlight lang="qbasic">10 print "Hello world!"</syntaxhighlight>
=={{header|ChucK}}==
<syntaxhighlight lang="text"><<< "Hello world!">>>;</syntaxhighlight>
=={{header|Cind}}==
<syntaxhighlight lang="cind">
execute() {
host.println("Hello world!");
}
</syntaxhighlight>
=={{header|Clay}}==
<
println("
}</
=={{header|Clean}}==
<
=={{header|Clio}}==
<syntaxhighlight lang="clio">'hello world!' -> print</syntaxhighlight>
=={{header|Clipper}}==
<syntaxhighlight lang="clipper">? "Hello world!"</syntaxhighlight>
=={{header|CLIPS}}==
<
=={{header|CLU}}==
<syntaxhighlight lang="clu">start_up = proc ()
po: stream := stream$primary_output()
stream$putl(po, "Hello world!")
end start_up</syntaxhighlight>
=={{header|Clojure}}==
<
=={{header|
<syntaxhighlight lang="cmake">message(STATUS "Hello world!")</syntaxhighlight>
This outputs
<pre>-- Hello world!</pre>
=={{header|COBOL}}==
Using fixed format.
{{works with|
{{works with|Dell Enterprise COBOL}}
<
procedure division.
display "
stop run.</
Using relaxed compilation rules, the hello program can become a single DISPLAY statement.
{{works with|GnuCOBOL}}
<syntaxhighlight lang="cobol">display"Hello, world".</syntaxhighlight>
<pre>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</pre>
''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.''
=={{header|Cobra}}==
<syntaxhighlight lang="cobra">class Hello
def main
print 'Hello world!'</syntaxhighlight>
=={{header|CoffeeScript}}==
{{works with|Node.js}}
<syntaxhighlight lang="coffeescript">console.log "Hello world!"</syntaxhighlight>
{{works with|Rhino engine}}
<syntaxhighlight lang="coffeescript">print "Hello world!"</syntaxhighlight>
=={{header|ColdFusion}}==
<syntaxhighlight lang="coldfusion"><cfoutput>Hello world!</cfoutput></syntaxhighlight>
=={{header|Comal}}==
<syntaxhighlight lang="comal">PRINT "Hello world!"</syntaxhighlight>
=={{header|Comefrom0x10}}==
<syntaxhighlight lang="cf0x10">'Hello world!'</syntaxhighlight>
<syntaxhighlight lang="cf0x10">"Hello world!"</syntaxhighlight>
=={{header|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.
<syntaxhighlight lang="gwbasic">10 print chr$(147);chr$(14);:REM 147=clear screen, 14=switch to lowercase mode
20 print "Hello world!"
30 end
</syntaxhighlight>
{{Out}}<pre>Hello world!</pre>
=={{header|Common Lisp}}==
<
Or
<syntaxhighlight lang="lisp">(print "Hello world!")</syntaxhighlight>
===Alternate solution===
I use [https://franz.com/downloads/clp/survey Allegro CL 10.1]
<syntaxhighlight lang="lisp">
;; Project : Hello world/Text
(format t "~a" "Hello world!")
</syntaxhighlight>
Output:
<pre>
Hello world!
</pre>
=={{header|Component Pascal}}==
<syntaxhighlight lang="oberon2">
MODULE Hello;
IMPORT Out;
PROCEDURE Do*;
BEGIN
Out.String("Hello world!"); Out.Ln
END Do;
END Hello.</syntaxhighlight>
Run command ''Hello.Do'' by commander.
=={{header|Coq}}==
<syntaxhighlight lang="coq">
Require Import Coq.Strings.String.
Eval compute in ("Hello world!"%string).
</syntaxhighlight>
=={{header|Corescript}}==
<syntaxhighlight lang="corescript">print Hello world!</syntaxhighlight>
=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";
print("Hello world!");
print_nl();</syntaxhighlight>
=={{header|Crack}}==
<syntaxhighlight lang="crack">
import crack.io cout;
cout `Hello world!\n`;
</syntaxhighlight>
=={{header|Craft Basic}}==
<syntaxhighlight lang="basic">print "Hello world!"</syntaxhighlight>
=={{header|Creative Basic}}==
<syntaxhighlight lang="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
</syntaxhighlight>
=={{header|Crystal}}==
<syntaxhighlight lang="ruby">puts "Hello world!"</syntaxhighlight>
=={{header|Curto}}==
<syntaxhighlight lang="curto">." Hola, mundo!"</syntaxhighlight>
=={{header|D}}==
{{works with|D|2.0}}
<syntaxhighlight lang="d">import std.stdio;
void main() {
writeln("Hello world!");
}</syntaxhighlight>
=={{header|Dafny}}==
<syntaxhighlight lang="dafny">
method Main() {
print "hello, world!\n";
assert 10 < 2;
}
</syntaxhighlight>
=={{header|Dao}}==
<
=={{header|
<syntaxhighlight lang="dart">main() {
var bye = 'Hello world!';
print("$bye");
}</syntaxhighlight>
=={{header|DataWeave}}==
<syntaxhighlight lang="dataweave">"Hello world!"</syntaxhighlight>
=={{header|DBL}}==
<syntaxhighlight lang="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</syntaxhighlight>
=={{header|Dc}}==
<syntaxhighlight lang="dc">[Hello world!]p</syntaxhighlight>
...or print a numerically represented string.
<syntaxhighlight lang="dc">5735816763073014741799356604682 P</syntaxhighlight>
=={{header|DCL}}==
<syntaxhighlight lang="dcl">$ write sys$output "Hello world!"</syntaxhighlight>
=={{header|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.
<syntaxhighlight lang="ddnc">
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
</syntaxhighlight>
=={{header|Delphi}}==
<syntaxhighlight lang="delphi">
program ProjectGoodbye;
{$APPTYPE CONSOLE}
begin
WriteLn('Hello world!');
end.
</syntaxhighlight>
=={{header|DeviousYarn}}==
<syntaxhighlight lang="deviousyarn">o:"Hello world!</syntaxhighlight>
=={{header|DIBOL-11}}==
<syntaxhighlight lang="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
</syntaxhighlight>
=={{header|Diego}}==
Once the caller has met the computer and its printer...
<syntaxhighlight lang="diego">with_computer(comp1)_printer(lp1)_text(Hello World!);</syntaxhighlight>
If the caller is the computer...
<syntaxhighlight lang="diego">with_me()_printer(lp1)_text(Hello World!);</syntaxhighlight>
...or can be shortened as...
<syntaxhighlight lang="diego">me()_ptr(lp1)_txt(Hello World!);</syntaxhighlight>
If the computer has more than one printer...
<syntaxhighlight lang="diego">me()_printer()_text(Hello World!);</syntaxhighlight>
If there are more than one computer which have zero or more printers...
<syntaxhighlight lang="diego">with_computer()_printer()_text(Hello World!);</syntaxhighlight>
If there are zero or more printers connected to any thing (device)...
<syntaxhighlight lang="diego">with_printer()_text(Hello World!);</syntaxhighlight>
=={{header|DIV Games Studio}}==
<syntaxhighlight lang="div">
PROGRAM HELLOWORLD;
BEGIN
WRITE_TEXT(0,160,100,4,"HELLO WORLD!");
LOOP
FRAME;
END
END
</syntaxhighlight>
=={{header|DM}}==
<syntaxhighlight lang="dm">
/client/New()
..()
src << "Hello world!"
</syntaxhighlight>
=={{header|Draco}}==
<syntaxhighlight lang="draco">proc nonrec main() void:
writeln("Hello world!")
corp</syntaxhighlight>
=={{header|Dragon}}==
<syntaxhighlight lang="dragon">
showln "Hello world!"
</syntaxhighlight>
=={{header|DreamBerd}}==
<syntaxhighlight lang="text">
print "Hello world!"!
</syntaxhighlight>
=={{header|dt}}==
<syntaxhighlight lang="dt">"Hello world!" pl</syntaxhighlight>
=={{header|DWScript}}==
<syntaxhighlight lang="delphi">
PrintLn('Hello world!');
</syntaxhighlight>
=={{header|Dyalect}}==
<syntaxhighlight lang="dyalect">print("Hello world!")</syntaxhighlight>
=={{header|Dylan}}==
<syntaxhighlight lang="dylan">
module: hello-world
format-out("%s\n", "Hello world!");
</syntaxhighlight>
=={{header|Dylan.NET}}==
{{works with|Mono|2.6.7}}
{{works with|Mono|2.10.x}}
{{works with|Mono|3.x.y}}
{{works with|.NET|3.5}}
{{works with|.NET|4.0}}
{{works with|.NET|4.5}}
One Line version:
<syntaxhighlight lang="dylan.net">Console::WriteLine("Hello world!")</syntaxhighlight>
Hello World Program:
<syntaxhighlight lang="dylan.net">
//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
</syntaxhighlight>
=={{header|Déjà Vu}}==
<syntaxhighlight lang="dejavu">!print "Hello world!"</syntaxhighlight>
=={{header|E}}==
<
stdout.println("
=={{header|EasyLang}}==
<syntaxhighlight lang="text">
print "Hello world!"
</syntaxhighlight>
=={{header|eC}}==
<
{
void Main()
{
PrintLn("
}
}</
=={{header|EchoLisp}}==
<syntaxhighlight lang="lisp">
(display "Hello world!" "color:blue")
</syntaxhighlight>
=={{header|ECL}}==
<syntaxhighlight lang="ecl">
OUTPUT('Hello world!');
</syntaxhighlight>
=={{header|Ecstasy}}==
<syntaxhighlight lang="java">
module HelloWorld {
void run() {
@Inject Console console;
console.print("Hello, World!");
}
}
</syntaxhighlight>
=={{header|Ed}}==
<syntaxhighlight>
a
Hello World!
.
p
Q
</syntaxhighlight>
=={{header|EDSAC order code}}==
The EDSAC did not support lower-case letters. The method used here is to include a separate <code>O</code> 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]].
<syntaxhighlight lang="edsac">[ 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 ]</syntaxhighlight>
{{out}}
<pre>HELLO WORLD</pre>
=={{header|Efene}}==
short version (without a function)
<
complete version (put this in a file and compile it)
<
run = fn () {
io.format("
}</
=={{header|Egel}}==
<syntaxhighlight lang="egel">
def main = "Hello World!"
</syntaxhighlight>
=={{header|Egison}}==
<syntaxhighlight lang="egison">
(define $main
(lambda [$argv]
(write-string "Hello world!\n")))
</syntaxhighlight>
=={{header|EGL}}==
{{works with|EDT}}
{{works with|RBD}}
<syntaxhighlight lang="egl">
program HelloWorld
function main()
SysLib.writeStdout("Hello world!");
end
end
</syntaxhighlight>
=={{header|Eiffel}}==
{{wikipedia|Eiffel (programming language)}}
<syntaxhighlight lang="eiffel">class
HELLO_WORLD
create
make
feature
make
do
print ("Hello world!%N")
end
end</syntaxhighlight>
=={{header|Ela}}==
<syntaxhighlight lang="ela">open monad io
do putStrLn "Hello world!" ::: IO</syntaxhighlight>
=={{header|Elan}}==
<syntaxhighlight lang="elan">putline ("Hello, world!");</syntaxhighlight>
=={{header|elastiC}}==
From the [http://www.elasticworld.org/man/elastic.html elastiC Manual].
<
// Import the `basic' package
Line 394 ⟶ 1,861:
{
// Print hello world
basic.print( "
}
Line 402 ⟶ 1,869:
// Invoke the `hello' function
hello();</
=={{header|Elena}}==
ELENA 6.x:
<syntaxhighlight lang="elena">public program()
{
console.writeLine("Hello world!")
}</syntaxhighlight>
=={{header|Elisa}}==
<syntaxhighlight lang="elisa"> "Hello world!"? </syntaxhighlight>
=={{header|Elixir}}==
<syntaxhighlight lang="elixir">
IO.puts "Hello world!"
</syntaxhighlight>
=={{header|Elm}}==
<syntaxhighlight lang="haskell">main = text "Goodbye World!"</syntaxhighlight>
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(message "Hello world!")</syntaxhighlight>
Alternatively, <code>princ</code> can be used:
<syntaxhighlight lang="lisp">(princ "Hello world!\n")</syntaxhighlight>
=={{header|EMal}}==
<syntaxhighlight lang="emal">writeLine("Hello world!")</syntaxhighlight>
=={{header|Emojicode}}==
<syntaxhighlight lang="emojicode">🏁 🍇
😀 🔤Hello world!🔤
🍉</syntaxhighlight>
=={{header|Enguage}}==
This shows "hello world", and shows how Enguage can generate this program on-the-fly.
<pre>
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.
</pre>
Output:
<pre>
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 +++
</pre>
=={{header|Erlang}}==
<
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
! Hello World in ERRE language
PROGRAM HELLO
BEGIN
PRINT("Hello world!")
END PROGRAM
</syntaxhighlight>
=={{header|Euler Math Toolbox}}==
<pre>
"Hello world!"
</pre>
=={{header|Extended BrainF***}}==
<syntaxhighlight lang="bf">[.>]@Hello world!</syntaxhighlight>
=={{header|Ezhil}}==
<span style="color:#FF0000">பதிப்பி</span><span style="color:#CD5C5C">"வணக்கம் உலகம்!"</span><br />
<span style="color:#FF0000">பதிப்பி</span><span style="color:#CD5C5C"> "Hello world!" </span><br />
<span style="color:#FF0000">பதிப்பி</span><span style="color:#CD5C5C">"******* வணக்கம்! மீண்டும் சந்திப்போம் *******"</span><br />
<span style="color:#8B0000">exit()</span>
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">printfn "%s" "Hello world!"</syntaxhighlight>
or using .Net classes directly
<syntaxhighlight lang="fsharp">System.Console.WriteLine("Hello world!")</syntaxhighlight>
=={{header|Factor}}==
<
=={{header|Falcon}}==
With the printl() function:
<syntaxhighlight lang="falcon">printl("Hello world!")</syntaxhighlight>
Or via "fast print":
<syntaxhighlight lang="falcon">> "Hello world!"</syntaxhighlight>
=={{header|FALSE}}==
<
"</
=={{header|Fantom}}==
<syntaxhighlight lang="fantom">
class HelloText
{
public static Void main ()
{
echo ("Hello world!")
}
}
</syntaxhighlight>
=={{header|Fe}}==
<syntaxhighlight lang="clojure">(print "Hello World")</syntaxhighlight>
=={{header|Fennel}}==
<syntaxhighlight lang="fennel">(print "Hello World")</syntaxhighlight>
=={{header|ferite}}==
word.}}
<syntaxhighlight lang="ferite">uses "console";
Console.println( "Goodby, World!" );</syntaxhighlight>
=={{header|Fermat}}==
<syntaxhighlight lang="fermat">!!'Hello, World!';</syntaxhighlight>
=={{header|Fexl}}==
<syntaxhighlight lang="fexl">say "Hello world!"</syntaxhighlight>
=={{header|Fhidwfe}}==
<syntaxhighlight lang="fhidwfe">puts$ "Hello, world!\n"</syntaxhighlight>
=={{header|Fish}}==
Standard Hello, world example, modified for this task:
<syntaxhighlight lang="fish">!v"Hello world!"r!
>l?!;o</syntaxhighlight>
Explanation of the code:<br/>
<tt>!v"</tt> jumps over the <tt>v</tt> character with the <tt>!</tt> sign, then starts the string mode with <tt>"</tt> .<br/>
Then the characters <tt>Hello world!</tt> are added, and string mode is closed with <tt>"</tt>.<br/>
The stack is reversed for printing (<tt>r</tt>), and a jump (<tt>!</tt>) is executed to jump over the <tt>!</tt> at the beginning of the line and execute the <tt>v</tt>. ([[Fish]] is torical)<br/>
After going down by <tt>v</tt>, it goes rightwards again by <tt>></tt> and this line is being executed.<br/>
This line pushes the stack size (<tt>l</tt>), and stops (<tt>;</tt>) if the top item on the stack is equal to 0 (<tt>?</tt>). Else it executes the <tt>!</tt> directly after it and jumps to the <tt>o</tt>, which outputs the top item in [http://en.wikipedia.org/wiki/Ascii ASCII]. Then the line is executed again. It effectively prints the stack until it's empty, then it terminates.
=={{header|FOCAL}}==
<syntaxhighlight lang="focal">TYPE "Hello, world" !</syntaxhighlight>
=={{header|Forth}}==
<
Or as a whole program:
<
=={{header|Fortran}}==
Line 439 ⟶ 2,039:
Simplest case - display using default formatting:
<
Use explicit output format:
<
print 100,"
Output to channels other than stdout goes like this:
<
uses the format given at label 100 to output to unit 89. If output unit with this number exists yet (no "<tt>OPEN</tt>" 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 "<tt>fort.89</tt>".
{{7*7}}
=={{header|Fortress}}==
<
run() = println("
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">? "Hello world!"
sleep</syntaxhighlight>
=={{header|Free Pascal}}==
<syntaxhighlight lang="pascal">
PROGRAM HelloWorld ;
{$APPTYPE CONSOLE}
(*)
https://www.freepascal.org/advantage.var
(*)
USES
crt;
BEGIN
WriteLn ( 'Hello world!' ) ;
END.
</syntaxhighlight>
=={{header|Frege}}==
{{Works with|Frege|3.20.113}}
<syntaxhighlight lang="frege">module HelloWorld where
main _ = println "Hello world!"</syntaxhighlight>
=={{header|friendly interactive shell}}==
Unlike other [[UNIX shell]] languages, fish doesn't support history substitution, so <code>!</code> is safe to use without quoting.
<syntaxhighlight lang="fishshell">echo Hello world!</syntaxhighlight>
=={{header|Frink}}==
<syntaxhighlight lang="frink">
println["Hello world!"]
</syntaxhighlight>
=={{header|FTCBASIC}}==
<syntaxhighlight lang="basic">print "Hello, world!"
pause
end</syntaxhighlight>
=={{header|FunL}}==
<syntaxhighlight lang="funl">println( 'Hello world!' )</syntaxhighlight>
=={{header|Furor}}==
<syntaxhighlight lang="furor">."Hello, World!\n"</syntaxhighlight>
=={{header|Peri}}==
<syntaxhighlight lang="peri">
."Hello, World!\n"
</syntaxhighlight>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">window 1
print @"Hello world!"
HandleEvents</syntaxhighlight>
=={{header|FUZE BASIC}}==
<syntaxhighlight lang="qbasic">PRINT "Hello world!"</syntaxhighlight>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=d3a51f670e4eb0f793b513b14329be51 Click this link to run this code]'''
<syntaxhighlight lang="gambas">Public Sub Main()
PRINT "Hello world!"
End</syntaxhighlight>
=={{header|GAP}}==
<
"Hello
Print("Hello
Display("Hello
f := OutputTextUser();
WriteLine(f, "Hello
CloseStream(f);</
=={{header|GB BASIC}}==
<syntaxhighlight lang="gb basic">10 print "Hello world!"</syntaxhighlight>
=={{header|gecho}}==
<syntaxhighlight lang="gecho">'Hello, <> 'World! print</syntaxhighlight>
=={{header|Gema}}==
Gema ia a preprocessor that reads an input file and writes an output file.
This code will write "
<
\B=
=={{header|Genie}}==
<syntaxhighlight lang="genie">
init
print "Hello world!"
</syntaxhighlight>
=={{header|Gentee}}==
<syntaxhighlight lang="gentee">func hello <main>
{
print("Hello world!")
}</syntaxhighlight>
=={{header|GFA Basic}}==
<syntaxhighlight lang="gfabasic">PRINT "Hello World"</syntaxhighlight>
=={{header|GLBasic}}==
<syntaxhighlight lang="glbasic">STDOUT "Hello world!"</syntaxhighlight>
=={{header|Gleam}}==
<syntaxhighlight lang="gleam">
import gleam/io
pub fn main() {
io.println("Hello world!")
}
</syntaxhighlight>
=={{header|Glee}}==
<
or
<syntaxhighlight lang="glee">'Hello world!'</syntaxhighlight>
or to display with double quotes
<syntaxhighlight lang="glee"> '"Goodbye,World!"'</syntaxhighlight>
or to display with single quotes
<syntaxhighlight lang="glee"> "'Goodbye,World!'"</syntaxhighlight>
=={{header|Global Script}}==
This uses the <code>gsio</code> I/O operations, which are designed to be simple to implement on top of Haskell and simple to use.
<syntaxhighlight lang="global script">λ _. print qq{Hello world!\n}</syntaxhighlight>
=={{header|GlovePIE}}==
<syntaxhighlight lang="glovepie">debug="Hello world!"</syntaxhighlight>
=={{header|GML}}==
<syntaxhighlight lang="c">show_message("Hello world!"); // displays a pop-up message
show_debug_message("Hello world!"); // sends text to the debug log or IDE</syntaxhighlight>
=={{header|Go}}==
<syntaxhighlight lang="go">package main
import "fmt"
func main() { fmt.Println("
=={{header|Golfscript}}==
<
=={{header|Gosu}}==
<syntaxhighlight lang="gosu">print("Hello world!")</syntaxhighlight>
=={{header|Grain}}==
<syntaxhighlight lang="grain">print("Hello world!")</syntaxhighlight>
=={{header|Groovy}}==
<
=={{header|GW-BASIC}}==
<syntaxhighlight lang="qbasic">10 PRINT "Hello world!"</syntaxhighlight>
=={{header|Hack}}==
<syntaxhighlight lang="hack"><?hh echo 'Hello world!'; ?></syntaxhighlight>
=={{header|Halon}}==
If the code in run in the REPL the output will be to stdout otherwise syslog LOG_DEBUG will be used.
<syntaxhighlight lang="halon">echo "Hello world!";</syntaxhighlight>
=={{header|Harbour}}==
<syntaxhighlight lang="visualfoxpro">? "Hello world!"</syntaxhighlight>
=={{header|Hare}}==
<syntaxhighlight lang="hare">use fmt;
export fn main() void = {
fmt::println("Hello, world!")!;
};</syntaxhighlight>
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">
main = putStrLn "Hello world!"
</syntaxhighlight>
=={{header|Haxe}}==
<syntaxhighlight lang="actionscript">trace("Hello world!");</syntaxhighlight>
=={{header|hexiscript}}==
<syntaxhighlight lang="hexiscript">println "Hello world!"</syntaxhighlight>
=={{header|HicEst}}==
<syntaxhighlight lang
=={{header|HLA}}==
<
#include("stdlib.hhf")
begin goodbyeWorld;
stdout.put( "
end goodbyeWorld;</
=={{header|HolyC}}==
<syntaxhighlight lang="holyc">"Hello world!\n";</syntaxhighlight>
=={{header|Hoon}}==
<syntaxhighlight lang="hoon">~& "Hello world!" ~</syntaxhighlight>
=={{header|Hopper}}==
<syntaxhighlight lang="csharp">program Hello
{
uses "/Source/Library/Boards/PiPico"
Hopper()
{
WriteLn("Hello world!");
loop
{
LED = !LED;
Delay(500);
}
}
}</syntaxhighlight>
{{out}}
In IDE, build hello.hs into hello.hexe, (press F7) and start debug (F5) or hm console monitor.
<pre>!> hello
Hello world!
</pre>
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)''.
=={{header|HPPPL}}==
<syntaxhighlight lang="hpppl">PRINT("Hello world!");</syntaxhighlight>
=={{header|HQ9+}}==
{{incorrect|HQ9+|output isn't consistent with the task's requirements (and is probably incapable of solving the task).}}
<syntaxhighlight lang="hq9plus">H</syntaxhighlight>
*Technically, HQ9+ can't print "Hello world!" text because of its specification.
- H : Print 'Hello World!'<br>
- Q : Quine<br>
- 9 : Print '99 Bottles of Beer'<br>
- + : Increase Pointer (useless!)
=={{header|Huginn}}==
<syntaxhighlight lang="huginn">#! /bin/sh
exec huginn --no-argv -E "${0}" "${@}"
#! huginn
main() {
print( "Hello World!\n" );
return ( 0 );
}</syntaxhighlight>
=={{header|HTML5}}==
<syntaxhighlight lang="html5">
<!DOCTYPE html>
<html>
<body>
<h1>Hello world!</h1>
</body>
</html>
</syntaxhighlight>
=={{header|Hy}}==
<syntaxhighlight lang="clojure">(print "Hello world!")</syntaxhighlight>
=={{header|i}}==
<syntaxhighlight lang="i">software {
print("Hello world!")
}</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
<syntaxhighlight lang="icon">procedure main()
write( "Hello world!" )
end</syntaxhighlight>
=={{header|IDL}}==
<syntaxhighlight lang
=={{header|Idris}}==
<syntaxhighlight lang="idris">module Main
main : IO ()
main = putStrLn "Hello world!"</syntaxhighlight>
=={{header|Inform 6}}==
<syntaxhighlight lang="inform 6">[Main;
print "Hello world!^";
];</syntaxhighlight>
=={{header|Inko}}==
<syntaxhighlight lang="inko">import std::stdio::stdout
stdout.print('Hello, world!')</syntaxhighlight>
=={{header|Insitux}}==
<syntaxhighlight lang="insitux">(print "Hello, world!")</syntaxhighlight>
=={{header|Intercal}}==
<syntaxhighlight lang="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</syntaxhighlight>
=={{header|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.
<syntaxhighlight lang="integer basic"> 10 PRINT "Hello world!"
20 END</syntaxhighlight>
=={{header|Io}}==
<
=={{header|Ioke}}==
<
=={{header|IS-BASIC}}==
<syntaxhighlight lang="is-basic">PRINT "Hello world!"</syntaxhighlight>
=={{header|Isabelle}}==
<syntaxhighlight lang="isabelle">theory Scratch
imports Main
begin
value ‹''Hello world!''›
end</syntaxhighlight>
=={{header|IWBASIC}}==
<syntaxhighlight lang="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
</syntaxhighlight>
=={{header|J}}==
<
Hello world!</syntaxhighlight>
Here are some redundant alternatives:
<
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!
</syntaxhighlight>
=={{header|Jack}}==
<syntaxhighlight lang="jack">class Main {
function void main () {
do Output.printString("Hello world!");
do Output.println();
return;
}
}</syntaxhighlight>
=={{header|Jacquard Loom}}==
This weaves the string "Hello world!"
<syntaxhighlight lang="jacquard">+---------------+
| |
| * * |
|* * * * |
|* * *|
|* * *|
|* * * |
| * * * |
| * |
+---------------+
+---------------+
| |
|* * * |
|* * * |
| * *|
| * *|
|* * * |
|* * * * |
| * |
+---------------+
+---------------+
| |
|* ** * * |
|******* *** * |
| **** * * ***|
| **** * ******|
| ****** ** * |
| * * * * |
| * |
+---------------+
+---------------+
| |
|******* *** * |
|******* *** * |
| ** *|
|* * * *|
|******* ** * |
|******* *** * |
| * |
+---------------+
+---------------+
| |
|******* *** * |
|******* *** * |
| * * * *|
| * * * *|
|******* ** * |
|******* ** * |
| * |
+---------------+
+---------------+
| |
|***** * *** * |
|******* *** * |
| * * * * |
| * * * |
|****** ** * |
|****** ** * |
| * |
+---------------+
+---------------+
| |
| * * * |
|***** * ***** |
|***** ** * ***|
|***** ** * ***|
|******* * ** |
| * * * * |
| * |
+---------------+
+---------------+
| |
| |
| * * |
| * * |
| * |
| * |
| |
| |
+---------------+</syntaxhighlight>
=={{header|Jai}}==
<syntaxhighlight lang="jai">
#import "Basic";
main :: () {
print("Hello, World!\n");
}
</syntaxhighlight>
=={{header|Jakt}}==
<syntaxhighlight lang="jakt">
fn main() {
println("Hello world!")
}
</syntaxhighlight>
=={{header|Janet}}==
<syntaxhighlight lang="janet">(print "Hello world!")</syntaxhighlight>
=={{header|Java}}==
<syntaxhighlight lang
{
public static void main(String[] args)
{
System.out.println("Hello world!");
}
}</syntaxhighlight>
=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">document.write("Hello world!");</syntaxhighlight>
{{works with|NJS|0.2.5}}
{{works with|Rhino}}
{{works with|SpiderMonkey}}
<syntaxhighlight lang
{{works with|JScript}}
<
{{works with|Node.js}}
<syntaxhighlight lang="javascript">console.log("Hello world!")</syntaxhighlight>
=={{header|JCL}}==
<syntaxhighlight lang="jcl">/*MESSAGE Hello world!</syntaxhighlight>
=={{header|Jinja}}==
<syntaxhighlight lang="jinja">
from jinja2 import Template
print(Template("Hello World!").render())
</syntaxhighlight>
A bit more convoluted, really using a template:
<syntaxhighlight lang="jinja">
from jinja2 import Template
print(Template("Hello {{ something }}!").render(something="World"))
</syntaxhighlight>
=={{header|Joy}}==
<
=={{header|jq}}==
<syntaxhighlight lang="jq">"Hello world!"</syntaxhighlight>
=={{header|JSE}}==
<syntaxhighlight lang="jse">Print "Hello world!"</syntaxhighlight>
=={{header|Jsish}}==
<syntaxhighlight lang="javascript">puts("Hello world!")</syntaxhighlight>
=={{header|Julia}}==
<syntaxhighlight lang="julia">println("Hello world!")</syntaxhighlight>
=={{header|K}}==
<syntaxhighlight lang="k">
"Hello world!"
</syntaxhighlight>
Some of the other ways this task can be attached are:
<syntaxhighlight lang="k">
`0: "Hello world!\n"
</syntaxhighlight>
<syntaxhighlight lang="k">
s: "Hello world!"
s
</syntaxhighlight>
<syntaxhighlight lang="k">
\echo "Hello world!"
</syntaxhighlight>
=={{header|Kabap}}==
<syntaxhighlight lang="kabap">return = "Hello world!";</syntaxhighlight>
=={{header|Kaya}}==
<syntaxhighlight lang="kaya">program hello;
Void main() {
// My first program!
putStrLn("Hello world!");
}</syntaxhighlight>
=={{header|Kdf9 Usercode}}==
{{incorrect|Kdf9|output isn't consistent with the task's requirements: wording, punctuation.}}
<syntaxhighlight lang="joy">
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;
</syntaxhighlight>
=={{header|Keg}}==
<syntaxhighlight lang="keg">Hello world\!</syntaxhighlight>
=={{header|Kite}}==
simply a single line
<syntaxhighlight lang="kite">"#!/usr/local/bin/kite
"Hello world!"|print;</syntaxhighlight>
=={{header|Kitten}}==
<syntaxhighlight lang="kitten">"Hello world!" say</syntaxhighlight>
=={{header|KL1}}==
<syntaxhighlight lang="prolog>
:- module main.
main :-
unix:unix([stdio(normal(S))]),
S = [fwrite("Hello world\n")].
</syntaxhighlight>
=={{header|Koka}}==
<syntaxhighlight lang="koka">fun main() {
println("Hello world!")
}</syntaxhighlight>
Alternatively:
- indentation instead of braces
- uniform function call syntax
- omitted parentheses for function calls with no parameters
<syntaxhighlight lang="koka">fun main()
"Hello world!".println
</syntaxhighlight>
=={{header|KonsolScript}}==
Displays it in a text file or console/terminal.
<syntaxhighlight lang="konsolscript">function main() {
Konsol:Log("Hello world!")
}</syntaxhighlight>
=={{header|Kotlin}}==
<syntaxhighlight lang="kotlin">fun main() {
println("Hello world!")
}</syntaxhighlight>
=={{header|KQL}}==
<syntaxhighlight lang="kql">print 'Hello world!'</syntaxhighlight>
=={{header|KSI}}==
<syntaxhighlight lang="ksi">
`plain
'Hello world!' #echo #
</syntaxhighlight>
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
Hello world!
{h1 Hello world!}
_h1 Hello world!\n
</syntaxhighlight>
=={{header|Lang}}==
<syntaxhighlight lang="lang">fn.println(Hello world!)</syntaxhighlight>
=={{header|Lang5}}==
<syntaxhighlight lang="lang5">"Hello world!\n" .</syntaxhighlight>
=={{header|langur}}==
<syntaxhighlight lang="langur">writeln "Hello"</syntaxhighlight>
=={{header|Lasso}}==
A plain string is output automatically.
<syntaxhighlight lang="lasso">'Hello world!'</syntaxhighlight>
=={{header|LaTeX}}==
<syntaxhighlight lang="latex">\documentclass{minimal}
\begin{document}
Hello World!
\end{document}</syntaxhighlight>
=={{header|Latitude}}==
<syntaxhighlight lang="latitude">putln "Hello world!".</syntaxhighlight>
=={{header|LC3 Assembly}}==
<syntaxhighlight lang="lc3asm">.orig x3000
LEA R0, hello ; R0 = &hello
TRAP x22 ; PUTS (print char array at addr in R0)
HALT
hello .stringz "Hello World!"
.end</syntaxhighlight>
Or (without PUTS)
<syntaxhighlight lang="lc3asm">.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</syntaxhighlight>
=={{header|LDPL}}==
<syntaxhighlight lang="ldpl">
procedure:
display "Hello World!" crlf
</syntaxhighlight>
=={{header|Lean}}==
<syntaxhighlight lang="lean">
#eval "Hello world!"
</syntaxhighlight>
Slightly longer version:
<syntaxhighlight lang="lean">
def main : IO Unit :=
IO.println ("Hello world!")
#eval main
</syntaxhighlight>
=={{header|LFE}}==
<syntaxhighlight lang="lisp">
(: io format '"Hello world!~n")
</syntaxhighlight>
=={{header|Liberty BASIC}}==
<
=={{header|LIL}}==
<syntaxhighlight lang="tcl">#
# Hello world in lil
#
print "Hello, world!"</syntaxhighlight>
=={{header|Lily}}==
There are two ways to do this. First, with the builtin print:
<syntaxhighlight lang="lily">print("Hello world!")</syntaxhighlight>
Second, by using stdout directly:
<syntaxhighlight lang="lily">stdout.print("Hello world!\n")</syntaxhighlight>
=={{header|LilyPond}}==
<syntaxhighlight lang="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!
}</syntaxhighlight>
=={{header|Limbo}}==
<
include "sys.m";
Line 584 ⟶ 2,865:
{
sys = load Sys Sys->PATH;
sys->print("
}</
=={{header|Lingo}}==
<syntaxhighlight lang="lingo">put "Hello world!"</syntaxhighlight>
or:
<syntaxhighlight lang="lingo">trace("Hello world!")</syntaxhighlight>
=={{header|Lisaac}}==
Line 591 ⟶ 2,879:
You can print to standard output in Lisaac by calling STRING.print or INTEGER.print:
<
+ name := GOODBYE; // Define the name of this object.
Section Public
- main <- ("
However, it may be more straightforward to use IO.print_string instead:
<
+ name := GOODBYE2; // Define the name of this object.
Section Public
- main <- (IO.put_string "
=={{header|Little}}==
Output to terminal:
<syntaxhighlight lang="c">puts("Hello world!");</syntaxhighlight>
Without the newline terminator:
<syntaxhighlight lang="c">puts(nonewline: "Hello world!");</syntaxhighlight>
Output to arbitrary open, writable file, for example the standard error channel:
<syntaxhighlight lang="c">puts(stderr, "Hello world!");</syntaxhighlight>
=={{header|LiveCode}}==
Examples using the full LiveCode IDE.
Text input and output done in the Message palette/window:
<syntaxhighlight lang="livecode">put "Hello World!"</syntaxhighlight>
Present a dialog box to the user
<syntaxhighlight lang="livecode">Answer "Hello World!"</syntaxhighlight>
Example using command-line livecode-server in shell script
<syntaxhighlight lang="livecode">#! /usr/local/bin/livecode-server
set the outputLineEndings to "lf"
put "Hello world!" & return</syntaxhighlight>
Livecode also supports stdout as a device to write to
<syntaxhighlight lang="livecode">write "Hello world!" & return to stdout</syntaxhighlight>
=={{header|LLVM}}==
<syntaxhighlight lang="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
}</syntaxhighlight>
=={{header|Lobster}}==
<syntaxhighlight lang="lobster">print "Hello world!"</syntaxhighlight>
=={{header|Logo}}==
Print includes a line feed:
<syntaxhighlight lang
Type does not:
<syntaxhighlight lang
=={{header|Logtalk}}==
<
% the initialization/1 directive argument is automatically executed
% when the object is loaded into memory:
:- initialization(
:- end_object.</
=={{header|
<syntaxhighlight lang="lolcode">
HAI
CAN HAS STDIO?
VISIBLE "Hello world!"
KTHXBYE
</syntaxhighlight>
=={{header|LotusScript}}==
<syntaxhighlight lang="lotusscript">:- object(hello_world).
'This will send the output to the status bar at the bottom of the Notes client screen
print "
:- end_object.</
=={{header|LSE}}==
<syntaxhighlight lang="lse">AFFICHER [U, /] 'Hello world!'</syntaxhighlight>
=={{header|LSE64}}==
<syntaxhighlight lang
=={{header|Lua}}==
Function calls with either a string literal or a table constructor passed as their only argument do not require parentheses.
<
Harder way with a table:
<syntaxhighlight lang="lua">
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))
</syntaxhighlight>
=={{header|Luna}}==
<syntaxhighlight lang="luna">def main:
hello = "Hello, World!"
print hello</syntaxhighlight>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="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
</syntaxhighlight>
=={{header|M4}}==
For the particular nature of m4, this is simply:
<syntaxhighlight lang
=={{header|
<syntaxhighlight lang="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
</syntaxhighlight>
=={{header|MACRO-11}}==
<syntaxhighlight lang="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
</syntaxhighlight>
=={{header|Maclisp}}==
<syntaxhighlight lang="lisp">(format t "Hello world!~%")</syntaxhighlight>
Or
<syntaxhighlight lang="lisp">(print "Hello world!")</syntaxhighlight>
=={{header|MAD}}==
<syntaxhighlight lang="mad"> VECTOR VALUES HELLO = $11HHELLO WORLD*$
PRINT FORMAT HELLO
END OF PROGRAM</syntaxhighlight>
=={{header|make}}==
Makefile contents:
<syntaxhighlight lang="make">
all:
$(info Hello world!)
</syntaxhighlight>
Running make produces:
Hello world!<br>
make: Nothing to be done for `all'.
=={{header|Malbolge}}==
'''Long version:'''
<syntaxhighlight lang="malbolge">('&%:9]!~}|z2Vxwv-,POqponl$Hjig%eB@@>}=<M:9wv6WsU2T|nm-,jcL(I&%$#"
`CB]V?Tx<uVtT`Rpo3NlF.Jh++FdbCBA@?]!~|4XzyTT43Qsqq(Lnmkj"Fhg${z@></syntaxhighlight>
'''Short version:'''
<syntaxhighlight lang="malbolge">(=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8dc</syntaxhighlight>
{{Out}}
<pre>HELLO WORLD!
</pre>
=={{header|MANOOL}}==
In “applicative” notation:
<syntaxhighlight lang="manool">{{extern "manool.org.18/std/0.3/all"} in WriteLine[Out; "Hello world!"]}</syntaxhighlight>
OOPish notation (equivalent to the above, up to Abstract Syntax Tree):
<syntaxhighlight lang="manool">{{extern "manool.org.18/std/0.3/all"} in Out.WriteLine["Hello world!"]}</syntaxhighlight>
LISPish notation (ditto):
<syntaxhighlight lang="manool">{{extern "manool.org.18/std/0.3/all"} in {WriteLine Out "Hello world!"}}</syntaxhighlight>
Using a colon punctuator (ditto):
<syntaxhighlight lang="manool">{{extern "manool.org.18/std/0.3/all"} in: WriteLine Out "Hello world!"}</syntaxhighlight>
Note that all semicolons, wherever allowed, are optional. The above example with all possible semicolons:
<syntaxhighlight lang="manool">{{extern; "manool.org.18/std/0.3/all"} in: WriteLine; Out; "Hello world!"}</syntaxhighlight>
=={{header|Maple}}==
<syntaxhighlight lang="maple">
> printf( "Hello world!\n" ): # print without quotes
Hello world!
</syntaxhighlight>
=={{header|Mastermind}}==
<syntaxhighlight lang="mastermind">output "Hello world!\n";</syntaxhighlight>
=={{header|Mathcad}}==
Simply type the following directly onto a Mathcad worksheet (''A worksheet is Mathcad's combined source code file & console'').
<syntaxhighlight lang="ayrch">"Hello, World!"</syntaxhighlight>
Applies to Mathcad Prime, Mathcad Prime Express and Mathcad 15 (''and earlier'')
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Print["Hello world!"]</syntaxhighlight>
=={{header|MATLAB}}==
<syntaxhighlight lang="matlab">>> disp('Hello world!')</syntaxhighlight>
=={{header|Maude}}==
<syntaxhighlight lang="maude">
fmod BYE-WORLD is
protecting STRING .
op sayBye : -> String .
eq sayBye = "Hello world!" .
endfm
red sayBye .
</syntaxhighlight>
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">print("Hello world!");</syntaxhighlight>
=={{header|MAXScript}}==
<
or:
<
=={{header|MDL}}==
<syntaxhighlight lang="mdl"><PRINC "Hello world!">
<CRLF></syntaxhighlight>
=={{header|MEL}}==
<syntaxhighlight lang="mel">proc helloWorld () {
print "Hello, world!\n";
} </syntaxhighlight>
=={{header|MelonBasic}}==
<syntaxhighlight lang="melonbasic">Say:Hello world!
helloWorld; </syntaxhighlight>
=={{header|Mercury}}==
<
:- interface.
:- import_module io.
Line 667 ⟶ 3,173:
:- implementation.
main(!IO) :-
io.write_string("
=={{header|Metafont}}==
<
=={{header|Microsoft Small Basic}}==
<syntaxhighlight lang="smallbasic">TextWindow.WriteLine("Hello world!")</syntaxhighlight>
=={{header|min}}==
<syntaxhighlight lang="min">"Hello world!" puts</syntaxhighlight>
=={{header|Minimal BASIC}}==
<syntaxhighlight lang="qbasic">10 PRINT "Hello world!"
20 END</syntaxhighlight>
=={{header|MiniScript}}==
<syntaxhighlight lang="miniscript">print "Hello world!"</syntaxhighlight>
=={{header|MiniZinc}}==
<syntaxhighlight lang="minizinc">
output ["Hello World"];
</syntaxhighlight>
{{out}}
<pre>Hello World
----------</pre>
=={{header|MIPS Assembly}}==
{{works with|MARS}} and {{works with|SPIM}}
<
hello: .asciiz "
.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
syscall # make the system call</syntaxhighlight>
=={{header|Miranda}}==
<syntaxhighlight lang="miranda">main :: [sys_message]
main = [Stdout "Hello, world!\n"]</syntaxhighlight>
=={{header|mIRC Scripting Language}}==
<syntaxhighlight lang="mirc">echo -ag Hello world!</syntaxhighlight>
=={{header|ML/I}}==
<syntaxhighlight lang="ml/i">Hello world!</syntaxhighlight>
=={{header|Modula-2}}==
<syntaxhighlight lang="modula2">MODULE Hello;
IMPORT InOut;
BEGIN
InOut.WriteString('Hello world!');
InOut.WriteLn
END Hello.</syntaxhighlight>
==={{header|TopSpeed Modula-2}}===
{{works with|TopSpeed (JPI) Modula-2 under DOSBox-X}}
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.
<syntaxhighlight lang="modula2">
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.
</syntaxhighlight>
=={{header|Modula-3}}==
<
IMPORT IO;
BEGIN
IO.Put("
END Goodbye.</
=={{header|MontiLang}}==
<syntaxhighlight lang="montilang">|Hello, World!| PRINT .</syntaxhighlight>
=={{header|Morfa}}==
<syntaxhighlight lang="morfa">
import morfa.io.print;
func main(): void
{
println("Hello world!");
}
</syntaxhighlight>
=={{header|Mosaic}}==
<syntaxhighlight lang="mosaic">proc main =
println "Hello, world"
end</syntaxhighlight>
Or just:
<syntaxhighlight lang="mosaic">
println "Hello, world"</syntaxhighlight>
=={{header|MSX Basic}}==
<syntaxhighlight lang="qbasic">10 PRINT "Hello world!"</syntaxhighlight>
=={{header|MUF}}==
<syntaxhighlight lang="muf">: main[ -- ]
me @ "Hello world!" notify
exit
;</syntaxhighlight>
=={{header|MUMPS}}==
<
=={{header|MyDef}}==
Run with: <pre>mydef_run hello.def</pre>
Perl:
<syntaxhighlight lang="mydef">$print Hello world</syntaxhighlight>
C:
<syntaxhighlight lang="mydef">
module: c
$print Hello world
</syntaxhighlight>
python:
<syntaxhighlight lang="mydef">
module: python
$print Hello world
</syntaxhighlight>
JavaScript
<syntaxhighlight lang="mydef">
module: js
$print "Hello world"
</syntaxhighlight>
go:
<syntaxhighlight lang="mydef">
module: go
$print Hello world
</syntaxhighlight>
=={{header|MyrtleScript}}==
<syntaxhighlight lang="myrtlescript">script HelloWorld {
func main returns: int {
print("Hello World!")
}
}
</syntaxhighlight>
=={{header|MySQL}}==
<syntaxhighlight lang="mysql">SELECT 'Hello world!';</syntaxhighlight>
=={{header|Mythryl}}==
<syntaxhighlight lang="mythryl">print "Hello world!";</syntaxhighlight>
=={{header|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.
<syntaxhighlight lang="n/t/roff">Hello world!</syntaxhighlight>
=={{header|Nanoquery}}==
<syntaxhighlight lang="nanoquery">println "Hello world!"</syntaxhighlight>
=={{header|Neat}}==
<syntaxhighlight lang="neat">void main() writeln "Hello world!";</syntaxhighlight>
=={{header|Neko}}==
<syntaxhighlight lang="neko">$print("Hello world!");</syntaxhighlight>
=={{header|Nemerle}}==
<syntaxhighlight lang="nemerle">
class Hello
{
static Main () : void
{
System.Console.WriteLine ("Hello world!");
}
}
</syntaxhighlight>
Easier method:
<syntaxhighlight lang="nemerle">
System.Console.WriteLine("Hello world!");
</syntaxhighlight>
=={{header|NetRexx}}==
<syntaxhighlight lang="netrexx">say 'Hello world!'</syntaxhighlight>
=={{header|Never}}==
<syntaxhighlight lang="fsharp">func main() -> int {
prints("Hello world!\n");
0
}</syntaxhighlight>
{{out}}
<pre>prompt$ never -f hello.nev
Hello world!</pre>
=={{header|newLISP}}==
{{works with|newLisp|6.1 and after}}
<
=={{header|
<syntaxhighlight lang="c">printf("Hello world!\n")</syntaxhighlight>
=={{header|Nim}}==
<syntaxhighlight lang="nim">echo("Hello world!")</syntaxhighlight>
using <code>stdout</code>
<syntaxhighlight lang="nim">stdout.writeLine("Hello World!")</syntaxhighlight>
=={{header|Nit}}==
<syntaxhighlight lang="nit">print "Hello world!"</syntaxhighlight>
=={{header|Nix}}==
<syntaxhighlight lang="nix">"Hello world!"</syntaxhighlight>
=={{header|NLP++}}==
<syntaxhighlight lang="nlp++">
@CODE
"output.txt" << "Hello world!";
@@CODE
</syntaxhighlight>
=={{header|NS-HUBASIC}}==
<p>As lowercase characters are not offered in NS-HUBASIC, perhaps some flexibility in the task specification could be offered.</p>
Using <code>?</code>:
<syntaxhighlight lang="ns-hubasic">10 ? "HELLO WORLD!"</syntaxhighlight>
Using <code>PRINT</code>:
<syntaxhighlight lang="ns-hubasic">10 PRINT "HELLO WORLD!"</syntaxhighlight>
=={{header|Nu}}==
<syntaxhighlight lang="nu">
print "Hello world!"
</syntaxhighlight>
=={{header|Nutt}}==
<syntaxhighlight lang="Nutt">
module hello_world
imports native.io.output.say
say("Hello, world!")
end
</syntaxhighlight>
=={{header|Nyquist}}==
'''Interpreter:''' [[Nyquist]] (3.15)
[[Category:Nyquist Version 3.15]]
===LISP syntax===
<syntaxhighlight lang="lisp">(format t "Hello world!")</syntaxhighlight>
Or
<syntaxhighlight lang="lisp">(print "Hello world!")</syntaxhighlight>
===SAL syntax===
<syntaxhighlight lang="sal">print "Hello World!"</syntaxhighlight>
Or
<syntaxhighlight lang="sal">exec format(t, "Hello World!")</syntaxhighlight>
=={{header|Oberon-2}}==
<syntaxhighlight lang="oberon2">
MODULE Goodbye;
IMPORT Out;
PROCEDURE World*;
BEGIN
Out.String("Hello world!");Out.Ln
END World;
BEGIN
World;
END Goodbye.
</syntaxhighlight>
=={{header|Objeck}}==
<syntaxhighlight lang
}
}</
=={{header|ObjectIcon}}==
<syntaxhighlight lang="objecticon">
import io
procedure main ()
io.write ("Hello world!")
end
</syntaxhighlight>
{{out}}
<pre>$ oiscript hello-OI.icn
Hello world!</pre>
=={{header|Objective-C}}==
{{works with|
The de facto Objective-C "Hello, World!" program is most commonly illustrated as the following, using the NSLog() function:
<syntaxhighlight lang="objc">
#import <Foundation/Foundation.h>
int main() {
@autoreleasepool {
NSLog(@"Hello, World!");
}
}
</syntaxhighlight>
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:
<syntaxhighlight lang="objc">
#import <Foundation/Foundation.h>
int main() {
@autoreleasepool {
NSFileHandle *standardOutput = [NSFileHandle fileHandleWithStandardOutput];
NSString *message = @"Hello, World!\n";
[standardOutput writeData:[message dataUsingEncoding:NSUTF8StringEncoding]];
}
}
</syntaxhighlight>
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.
<syntaxhighlight lang="objc">
#import <Foundation/Foundation.h>
int main() {
@autoreleasepool {
NSString *message = @"Hello, World!\n";
printf("%s", message.UTF8String);
}
}
</syntaxhighlight>
=={{header|OCaml}}==
<
=={{header|Occam}}==
{{works with|kroc}}
<syntaxhighlight lang="occam">#USE "course.lib"
PROC main (CHAN BYTE screen!)
out.string("Hello world!*c*n", 0, screen)
:</syntaxhighlight>
=={{header|Octave}}==
<
Or, using C-style function printf:
<
=={{header|Odin}}==
<syntaxhighlight lang="odin">package main
import "core:fmt"
main :: proc() {
fmt.println("Hellope!");
}</syntaxhighlight>
=={{header|Oforth}}==
<syntaxhighlight lang="oforth">"Hello world!" .</syntaxhighlight>
=={{header|Ol}}==
<syntaxhighlight lang="scheme">(print "Hello world!")</syntaxhighlight>
=={{header|Onyx}}==
<
=={{header|
<syntaxhighlight lang="TS">
use core {printf}
main :: () {
printf("Hello world!");
}
</syntaxhighlight>
{{out}}
<pre>
Hello world!
</pre>
=={{header|OOC}}==
To print a String, either call its println() method:
<syntaxhighlight lang="ooc">main: func {
"Hello world!" println()
}</syntaxhighlight>
Or call the free println() function with the String as the argument.
<syntaxhighlight lang="ooc">main: func {
println("Hello world!")
}</syntaxhighlight>
=={{header|ooRexx}}==
Refer also to the [[#REXX|Rexx]] and [[#NetRexx|NetRexx]] solutions. Simple output is common to most Rexx dialects.
<syntaxhighlight lang="oorexx">/* Rexx */
say 'Hello world!'
</syntaxhighlight>
=={{header|OpenLisp}}==
We can use the same code as the Common Lisp example, but as a shell script.
<syntaxhighlight lang="openlisp">
#!/openlisp/uxlisp -shell
(format t "Hello world!~%")
(print "Hello world!")
</syntaxhighlight>
Output:
Hello world!
"Hello world!"
=={{header|Openscad}}==
<syntaxhighlight lang="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
</syntaxhighlight>
=={{header|Owl Lisp}}==
<syntaxhighlight lang="scheme">
(print "Hello world!")
</syntaxhighlight>
{{out}}
<pre>$ ol hello-Owl.scm
Hello world!</pre>
=={{header|Oxygene}}==
From [[wp:Oxygene (programming language)]]
<syntaxhighlight lang="pascal">
namespace HelloWorld;
interface
type
HelloClass = class
public
class method Main;
end;
implementation
class method HelloClass.Main;
begin
writeLn('Hello world!');
end;
end.
</syntaxhighlight>
{{out}}
<pre>
Hello world!
</pre>
=={{header|Oz}}==
<syntaxhighlight lang="oz">{Show "Hello world!"}</syntaxhighlight>
=={{header|PARI/GP}}==
<syntaxhighlight lang="parigp">print("Hello world!")</syntaxhighlight>
=={{header|Pascal}}==
{{works with|Free Pascal}}
<
begin
writeln('
end.</
=={{header|
<syntaxhighlight lang="pascal">
// Hello world/Text. Nigel Galloway: January 25th., 2023
begin
System.Console.WriteLine('Hello World!');
end.
</syntaxhighlight>
PascalABC.NET supports classical pascal syntax:
<syntaxhighlight lang="pascal">
program HelloWorld;
begin
writeln('Hello World!');
end.
</syntaxhighlight>
New syntax for an "one line" program
<syntaxhighlight lang="pascal">
##
println('Hello World!');
</syntaxhighlight>
{{out}}
<pre>
Hello World!
</pre>
=={{header|PASM}}==
<syntaxhighlight lang="pasm">print "Hello world!\n"
end</syntaxhighlight>
=={{header|
This can be assembled with macro1.c distributed with SIMH and then run on the SIMH PDP-1 simulator.
<syntaxhighlight lang="assembly">
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
</syntaxhighlight>
=={{header|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|1}} to {{works with|UNIX|7}}
<
.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: <
outlen = . - outtext</
=={{header|Pebble}}==
<syntaxhighlight lang="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</syntaxhighlight>
=={{header|PepsiScript}}==
The letters are only outputted in uppercase in the running program. However, lowercase characters can be used in the code instead.
For typing:
<syntaxhighlight lang="pepsiscript">#include default-libraries
#author Childishbeat
class Hello world/Text:
function Hello world/Text:
print "Hello world!"
end</syntaxhighlight>
For importing:
•dl◘Childishbeat◙♦Hello world/Text♪♣Hello_world!♠
=={{header|Perl}}==
{{works with|Perl|5.8.8}}
<syntaxhighlight lang="perl">print "Hello world!\n";</syntaxhighlight>
{{works with|Perl|5.10.x}}
Backported from Raku:
<syntaxhighlight lang="perl">use feature 'say';
say 'Hello world!';</syntaxhighlight>
or:
<syntaxhighlight lang="perl">use 5.010;
say 'Hello world!';</syntaxhighlight>
=={{header|Peylang}}==
<syntaxhighlight lang="peylang">chaap 'Hello world!';</syntaxhighlight>
{{out}}
<pre>
$ peyman hello.pey
Hello world!
</pre>
=={{header|Pharo}}==
<syntaxhighlight lang="pharo">"Comments are in double quotes"
"Sending message printString to 'Hello World' string"
'Hello World' printString</syntaxhighlight>
=={{header|Phix}}==
{{libheader|Phix/basics}}
<!--<syntaxhighlight lang="phix">-->
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Hello world!"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
=={{header|PHL}}==
<syntaxhighlight lang="phl">module helloworld;
extern printf;
@Integer main [
printf("Hello world!");
return 0;
]</syntaxhighlight>
=={{header|PHP}}==
<
echo "
?></
Alternatively, any text outside of the <code><?php ?></code> tags will be automatically echoed:
<syntaxhighlight lang
=={{header|Picat}}==
<syntaxhighlight lang="picat">println("Hello, world!")</syntaxhighlight>
=={{header|PicoLisp}}==
<
=={{header|Pict}}==
Using the syntax sugared version:
<syntaxhighlight lang="pict">(prNL "Hello World!");</syntaxhighlight>
Using the channel syntax:
<syntaxhighlight lang="pict">new done: ^[]
run ( prNL!["Hello World!" (rchan done)]
| done?_ = () )</syntaxhighlight>
=={{header|Pikachu}}==
<syntaxhighlight lang="pict">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</syntaxhighlight>
=={{header|Pike}}==
<syntaxhighlight lang="pike">int main(){
write("Hello world!\n");
}</syntaxhighlight>
=={{header|PILOT}}==
<syntaxhighlight lang="pilot">T:Hello world!</syntaxhighlight>
=={{header|PIR}}==
<syntaxhighlight lang="pir">.sub hello_world_text :main
print "Hello world!\n"
.end</syntaxhighlight>
=={{header|Pixilang}}==
<syntaxhighlight lang="pixilang">fputs("Hello world!\n")</syntaxhighlight>
=={{header|PL/I}}==
<syntaxhighlight lang="pli">goodbye:proc options(main);
put list('Hello world!');
end goodbye;</syntaxhighlight>
=={{header|
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.
<syntaxhighlight lang="pli">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</syntaxhighlight>
=={{header|PL/SQL}}==
{{works with|Oracle}}
<syntaxhighlight lang="plsql">
set serveroutput on
BEGIN
DBMS_OUTPUT.PUT_LINE('Hello world!');
END;
/
</syntaxhighlight>
<pre>
SQL> set serveroutput on
SQL>
SQL> BEGIN
2 DBMS_OUTPUT.PUT_LINE('Hello world!');
3 END;
4 /
Hello world!
PL/SQL procedure successfully completed.
</pre>
=={{header|Plain English}}==
<syntaxhighlight lang="plainenglish">\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.</syntaxhighlight>
=={{header|Plan}}==
This prints HELLO WORLD on operator's console.
<syntaxhighlight lang="plan">#STEER LIST,BINARY
#PROGRAM HLWD
#LOWER
MSG1A 11HHELLO WORLD
MSG1B 11/MSG1A
#PROGRAM
#ENTRY 0
DISTY MSG1B
SUSWT 2HHH
#END
#FINISH
#STOP</syntaxhighlight>
=={{header|Pointless}}==
<syntaxhighlight lang="pointless">
output = println("Hello world!")
</syntaxhighlight>
=={{header|Pony}}==
<syntaxhighlight lang="pony">actor Main
new create(env: Env) =>
env.out.print("Hello world!")</syntaxhighlight>
=={{header|Pop11}}==
<syntaxhighlight lang
=={{header|
Portugol keywords are Portuguese words.
<syntaxhighlight lang="portugol">
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
}
}
</syntaxhighlight>
=={{header|PostScript}}==
To generate a document that shows the text "Hello world!":
<syntaxhighlight lang="postscript">%!PS
/Helvetica 20 selectfont
70 700 moveto
(Hello world!) show
showpage</syntaxhighlight>
If the viewer has a console, then there are the following ways to display the topmost element of the stack:
<syntaxhighlight lang="postscript">(Hello world!) ==</syntaxhighlight>
will display the <i>string</i> "(Hello world!)";
<syntaxhighlight lang
will display the <i>content</i> of the string "(Hello world!)"; that is, "Hello world!";
<syntaxhighlight lang="postscript">(Hello world!) print</syntaxhighlight>
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:
<syntaxhighlight lang="postscript">%!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</syntaxhighlight>
=={{header|Potion}}==
<syntaxhighlight lang="potion">"Hello world!\n" print</syntaxhighlight>
=={{header|PowerBASIC}}==
<syntaxhighlight lang="powerbasic">#COMPILE EXE
#COMPILER PBCC 6
FUNCTION PBMAIN () AS LONG
CON.PRINT "Hello world!"
CON.WAITKEY$
END FUNCTION</syntaxhighlight>
=={{header|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).
<syntaxhighlight lang="powershell">'Hello world!'</syntaxhighlight>
=={{header|Processing}}==
<syntaxhighlight lang="processing">println("Hello world!");</syntaxhighlight>
=={{header|ProDOS}}==
<syntaxhighlight lang="prodos">printline Hello world!</syntaxhighlight>
=={{header|Programming Language}}==
For typing:
<syntaxhighlight lang="programming language">print(Hello world!)</syntaxhighlight>
For importing:
[print(Hello world!)]
=={{header|ProgressBASIC}}==
10 PRINT "Hello world"
=={{header|Prolog}}==
<syntaxhighlight lang="prolog">:- write('Hello world!'), nl.</syntaxhighlight>
=={{header|PROMAL}}==
<syntaxhighlight lang="promal">
program hello
include library
begin
output "Hello world!"
end
</syntaxhighlight>
=={{header|PSQL}}==
EXECUTE BLOCK
RETURNS(S VARCHAR(40))
AS
BEGIN
S = 'Hello world!';
SUSPEND;
END
=={{header|Pure}}==
<syntaxhighlight lang="pure">
using system;
puts "Hello world!\n" ;
</syntaxhighlight>
=={{header|PureBasic}}==
<
PrintN("
Input() ; Wait for enter</
using <code>Debug</code>
<syntaxhighlight lang="purebasic">Debug("Hello world!")</syntaxhighlight>
=={{header|Python}}==
{{works with|Python|2.4}}
<
The same using sys.stdout
<
sys.stdout.write("
In Python 3.0, print is
{{works with|Python|3.0}} (And version 2.X too).
<
'''An easter egg'''
The first two examples print <code>Hello, world!</code> once, and the last one prints it twice.
<syntaxhighlight lang="python">import __hello__</syntaxhighlight>
<syntaxhighlight lang="python">import __phello__</syntaxhighlight>
<syntaxhighlight lang="python">import __phello__.spam</syntaxhighlight>
=={{header|QB64}}==
<syntaxhighlight lang="qbasic">PRINT "Hello world!"</syntaxhighlight>
=={{header|Quackery}}==
<syntaxhighlight lang="quackery">say "Hello world!"</syntaxhighlight>
=={{header|Quill}}==
<syntaxhighlight lang="quill">"Hello world!" print</syntaxhighlight>
=={{header|Quite BASIC}}==
<syntaxhighlight lang="quite basic">10 print "Hello world!"</syntaxhighlight>
=={{header|R}}==
<
or
<syntaxhighlight lang="r"> message("Hello world!")</syntaxhighlight>
or
<syntaxhighlight lang="r"> print("Hello world!")</syntaxhighlight>
=={{header|Ra}}==
<syntaxhighlight lang="ra">
class HelloWorld
**Prints "Hello world!"**
on start
print "Hello world!"
</syntaxhighlight>
=={{header|Racket}}==
<syntaxhighlight lang="racket">
(printf "Hello world!\n")
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>say 'Hello world!';</syntaxhighlight>
In an object-oriented approach, the string is treated as an object calling its '''say()''' method:
<syntaxhighlight lang="raku" line>"Hello, World!".say();</syntaxhighlight>
=={{header|Raven}}==
<syntaxhighlight lang
=={{header|RATFOR}}==
<syntaxhighlight lang="ratfor">
program hello
write(*,101)"Hello World"
101 format(A)
end
</syntaxhighlight>
=={{header|RASEL}}==
<syntaxhighlight lang="text">A"!dlroW ,olleH">:?@,Hj</syntaxhighlight>
=={{header|REALbasic}}==
{{works with|REALbasic|5.5}}
This requires a console application.
<syntaxhighlight lang="realbasic">Function Run(args() as String) As Integer
Print "Hello world!"
Quit
End Function</syntaxhighlight>
=={{header|REBOL}}==
<
=={{header|RED}}==
<syntaxhighlight lang="red">print "Hello world!"</syntaxhighlight>
=={{header|Refal}}==
<syntaxhighlight lang="refal">$ENTRY Go {
= <Prout 'Hello, world!'>;
};</syntaxhighlight>
=={{header|Relation}}==
<syntaxhighlight lang="relation">
' Hello world!
</syntaxhighlight>
=={{header|ReScript}}==
<syntaxhighlight lang="rescript">Js.log("Hello world!")</syntaxhighlight>
{{out}}
<pre>
$ bsc hello.res > hello.bs.js
$ node hello.bs.js
Hello world!
</pre>
=={{header|Retro}}==
<syntaxhighlight lang="retro">
'Hello_world! s:put
</syntaxhighlight>
=={{header|REXX}}==
===using SAY===
<syntaxhighlight lang="rexx">/*REXX program to show a line of text. */
say '
===using SAY variable===
<syntaxhighlight lang="rexx">/*REXX program to show a line of text. */
yyy = 'Hello world!'
say yyy</syntaxhighlight>
===using LINEOUT===
<syntaxhighlight lang="rexx">/*REXX program to show a line of text. */
call lineout ,"Hello world!"</syntaxhighlight>
=={{header|Rhovas}}==
<syntaxhighlight lang="360 assembly">
print("Hello world!");
</syntaxhighlight>
=={{header|Ring}}==
<syntaxhighlight lang="ring">See "Hello world!"</syntaxhighlight>
=={{header|RISC-V Assembly}}==
<syntaxhighlight lang="risc-v">.data
hello:
.string "Hello World!\n\0"
.text
main:
la a0, hello
li a7, 4
ecall
li a7, 10
ecall
</syntaxhighlight>
=={{header|Roc}}==
<syntaxhighlight lang="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!"
</syntaxhighlight>
=={{header|Rockstar}}==
<syntaxhighlight lang="rockstar">Shout "Hello world!"</syntaxhighlight>
=={{header|RPG}}==
<nowiki>**</nowiki>free<br>
dsply 'Hello World!';
=={{header|RPL}}==
≪ "Hello world!" 1 DISP
1 FREEZE <span style="color:grey">@ remove this line on HP-28 models</span>
≫ '<span style="color:blue">TASK</span>' STO
=={{header|RTL/2}}==
<
LET NL=10;
Line 893 ⟶ 4,255:
ENT PROC INT RRJOB();
TWRT("
RETURN(1);
ENDPROC;</
=={{header|Ruby}}==
{{works with|Ruby|1.8.4}}
<
or
<
or even
<syntaxhighlight lang="ruby"> STDOUT.write "Hello world!\n"</syntaxhighlight>
'''Using the > global'''
<syntaxhighlight lang="ruby">$>.puts "Hello world!"</syntaxhighlight>
<syntaxhighlight lang="ruby">$>.write "Hello world!\n"</syntaxhighlight>
=={{header|Run BASIC}}==
<syntaxhighlight lang="runbasic">print "Hello world!"</syntaxhighlight>
=={{header|Rust}}==
<syntaxhighlight lang="rust">
fn main() {
print!("Hello world!");
}
</syntaxhighlight>
or
<syntaxhighlight lang="rust">
fn main() {
println!("Hello world!");
}
</syntaxhighlight>
=={{header|Salmon}}==
<syntaxhighlight lang="salmon">"Hello world!"!</syntaxhighlight>
or
<syntaxhighlight lang="salmon">print("Hello world!\n");</syntaxhighlight>
or
<syntaxhighlight lang="salmon">standard_output.print("Hello world!\n");</syntaxhighlight>
=={{header|SAS}}==
<syntaxhighlight lang="sas">/* Using a data step. Will print the string in the log window */
data _null_;
put "Hello world!";
run;</syntaxhighlight>
=={{header|SASL}}==
Note that a string starts with a single and ends with a double quote
<syntaxhighlight lang="sasl">
'Hello World!",nl
</syntaxhighlight>
=={{header|Sather}}==
<
main is
#OUT+"
end;
end;</
=={{header|Scala}}==
{{libheader|Console}}
===Ad hoc REPL solution===
Ad hoc solution as [http://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop REPL] script. Type this in a REPL session:
<syntaxhighlight lang="scala">println("Hello world!")</syntaxhighlight>
===Via Java runtime===
This is a call to the Java run-time library. '''Not recommended'''.
<syntaxhighlight lang="scala">System.out.println("Hello world!")</syntaxhighlight>
===Via Scala Console API===
This is a call to the Scala run-time library. '''Recommended'''.
<syntaxhighlight lang="scala">println("Hello world!")</syntaxhighlight>
===Short term deviation to out===
<syntaxhighlight lang="scala">Console.withErr(Console.out) { Console.err.println("This goes to default _out_") }</syntaxhighlight>
===Long term deviation to out===
<syntaxhighlight lang="scala"> Console.err.println ("Err not deviated")
Console.setErr(Console.out)
Console.err.println ("Err deviated")
Console.setErr(Console.err) // Reset to normal</syntaxhighlight>
=={{header|Scheme}}==
All Scheme implementations display the value of the last evaluated expression before the program terminates.
<syntaxhighlight lang="scheme">"Hello world!"</syntaxhighlight>
The <tt>display</tt> and <tt>newline</tt> 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===
<syntaxhighlight lang="scheme">(display "Hello world!")
(newline)</syntaxhighlight>
===R6RS===
<syntaxhighlight lang="scheme">(import (rnrs base (6))
(rnrs io simple (6)))
(display "Hello world!")
(newline)</syntaxhighlight>
===R7RS===
<syntaxhighlight lang="scheme">(import (scheme base)
(scheme write))
(display "Hello world!")
(newline)</syntaxhighlight>
=={{header|Scilab}}==
<syntaxhighlight lang="scilab">disp("Hello world!");</syntaxhighlight>
=={{header|ScratchScript}}==
<syntaxhighlight lang="scratchscript">print "Hello world!"</syntaxhighlight>
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.
<syntaxhighlight lang="scratchscript">print "Hello world!"
delayOnClick</syntaxhighlight>
=={{header|sed}}==
<syntaxhighlight lang="sed">i\
Hello world!
q</syntaxhighlight>
=={{header|Seed7}}==
<
const proc: main is func
begin
writeln("
end func;</
=={{header|
<syntaxhighlight lang="self">'Hello world!' printLine.</syntaxhighlight>
=={{header|
<syntaxhighlight lang="sensetalk">put "Hello world!"</syntaxhighlight>
=={{header|
<syntaxhighlight lang="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</syntaxhighlight>
=={{header|SETL}}==
<syntaxhighlight lang="setl">print("Hello world!");</syntaxhighlight>
=={{header|SETL4}}==
<syntaxhighlight lang="setl4">out("Hello world!");end</syntaxhighlight>
=={{header|Shen}}==
<syntaxhighlight lang="shen">(output "Hello world!~%")</syntaxhighlight>
=={{header|Shiny}}==
<syntaxhighlight lang="shiny">say 'Hello world!'</syntaxhighlight>
=={{header|Sidef}}==
<syntaxhighlight lang="sidef">„Hello world!”.say;</syntaxhighlight>
=={{header|SimpleCode}}==
The letters are only outputted in uppercase in the running program. However, lowercase characters can be used in the code instead.
<syntaxhighlight lang="simplecode">dtxt
Hello world!</syntaxhighlight>
=={{header|SIMPOL}}==
<
end function "
=={{header|Simula}}==
{{works with|SIMULA-67}}
<syntaxhighlight lang="simula">BEGIN
OUTTEXT("Hello world!");
OUTIMAGE
END</syntaxhighlight>
=={{header|Sing}}==
<syntaxhighlight lang="sing">requires "sio";
public fn singmain(argv [*]string) i32
{
sio.print("hello world !\r\n");
return(0);
}</syntaxhighlight>
=={{header|Sisal}}==
<
% Sisal doesn't yet have a string built-in.
Line 949 ⟶ 4,457:
function main(returns string)
"Hello world!"
end function</
=={{header|Skew}}==
{{works with|skewc|0.9.19}}
<syntaxhighlight lang="skew">
@entry
def main {
dynamic.console.log("Hello world!")
}
</syntaxhighlight>
=={{header|SkookumScript}}==
<syntaxhighlight lang="javascript">print("Hello world!")</syntaxhighlight>
Alternatively if just typing in the SkookumIDE [http://skookumscript.com/docs/v3.0/ide/console/workspace/ REPL]:
<syntaxhighlight lang="javascript">"Hello world!"</syntaxhighlight>
=={{header|Slate}}==
<syntaxhighlight lang="slate">inform: 'Hello world!'.</syntaxhighlight>
=={{header|Slope}}==
<syntaxhighlight lang="slope">(write "Hello, world!")</syntaxhighlight>
=={{header|SmallBASIC}}==
<syntaxhighlight lang="smallbasic">PRINT "Hello world!"</syntaxhighlight>
=={{header|Smalltalk}}==
<
{{works with|GNU Smalltalk}} (as does the above code)
<syntaxhighlight lang="smalltalk">'Hello world!' printNl.</syntaxhighlight>
=={{header|smart BASIC}}==
<syntaxhighlight lang="qbasic">PRINT "Hello world!"</syntaxhighlight>
=={{header|SmileBASIC}}==
<syntaxhighlight lang="smilebasic">PRINT "Hello world!"</syntaxhighlight>
=={{header|SNOBOL4}}==
Using CSnobol4 dialect
<
END</
=={{header|SNUSP}}==
===Core SNUSP===
<syntaxhighlight lang="snusp">/++++!/===========?\>++.>+.+++++++..+++\
\+++\ | /+>+++++++>/ /++++++++++<<.++>./
$+++/ | \+++++++++>\ \+++++.>.+++.-----\
\==-<<<<+>+++/ /=.>.+>.--------.-/</syntaxhighlight>
===Modular SNUSP===
<syntaxhighlight lang="snusp">@\G.@\o.o.@\d.--b.@\y.@\e.>@\comma.@\.<-@\W.+@\o.+++r.------l.@\d.>+.! #
| | \@------|# | \@@+@@++|+++#- \\ -
| \@@@@=+++++# | \===--------!\===!\-----|-------#-------/
\@@+@@@+++++# \!#+++++++++++++++++++++++#!/</
=={{header|Soda}}==
<syntaxhighlight lang="soda">
class Main
main (arguments : Array [String] ) : Unit =
println ("Hello world!")
end
</syntaxhighlight>
=={{header|SoneKing Assembly}}==
<syntaxhighlight lang="soneking assembly">
extern print
dv Msg Goodbye,World!
mov eax Msg
push
call print
pop
</syntaxhighlight>
=={{header|SPARC Assembly}}==
<syntaxhighlight lang="sparc">
.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:
</syntaxhighlight>
=={{header|Sparkling}}==
<syntaxhighlight lang="sparkling">print("Hello world!");</syntaxhighlight>
=={{header|SPL}}==
<syntaxhighlight lang="spl">#.output("Hello world!")</syntaxhighlight>
=={{header|SQL}}==
{{works with|Oracle}}
{{works with|Db2 LUW}}
<syntaxhighlight lang="sql">
select 'Hello world!' text from dual;
</syntaxhighlight>
<pre>
SQL>select 'Hello world!' text from dual;
TEXT
------------
Hello world!
</pre>
=={{header|SQL PL}}==
{{works with|Db2 LUW}}
With SQL only:
<syntaxhighlight lang="sql pl">
SELECT 'Hello world!' AS text FROM sysibm.sysdummy1;
</syntaxhighlight>
Output:
<pre>
db2 -t
db2 => SELECT 'Hello world!' AS text FROM sysibm.sysdummy1;
TEXT
------------
Hello world!
1 record(s) selected.
</pre>
{{works with|Db2 LUW}} version 9.7 or higher.
With SQL PL:
<syntaxhighlight lang="sql pl">
SET SERVEROUTPUT ON;
CALL DBMS_OUTPUT.PUT_LINE('Hello world!');
</syntaxhighlight>
Output:
<pre>
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!
</pre>
=={{header|Standard ML}}==
<
=={{header|Stata}}==
<syntaxhighlight lang="stata">display "Hello world!"</syntaxhighlight>
=={{header|Suneido}}==
<
=={{header|
<syntaxhighlight lang="swahili">andika("Hello world!")</syntaxhighlight>
=={{header|Swift}}==
{{works with|Swift|2.x+}}
<syntaxhighlight lang="swift">print("Hello world!")</syntaxhighlight>
{{works with|Swift|1.x}}
<syntaxhighlight lang="swift">println("Hello world!")</syntaxhighlight>
=={{header|Symstatic}}==
<syntaxhighlight lang="symstatic">println("Hello world!")</syntaxhighlight>
=={{header|Symsyn}}==
<syntaxhighlight lang="symsyn">
'hello world' []
</syntaxhighlight>
=={{header|TailDot}}==
<syntaxhighlight lang=taildot>c,x,Hello World!,v,x</syntaxhighlight>
=={{header|Tailspin}}==
<syntaxhighlight lang="tailspin">'Hello World' -> !OUT::write</syntaxhighlight>
=={{header|Tcl}}==
Output to terminal:
<syntaxhighlight lang="tcl">puts stdout {Hello world!}</syntaxhighlight>
Output to arbitrary open, writable file:
<syntaxhighlight lang
=={{header|Teco}}==
Outputting to terminal. Please note that ^A means control-A, not a caret followed by 'A', and that $ represent the ESC key.
<syntaxhighlight lang="teco">^AHello world!^A$$</syntaxhighlight>
=={{header|Tern}}==
<syntaxhighlight lang="tern">println("Hello world!");</syntaxhighlight>
=={{header|Terra}}==
<syntaxhighlight lang="terra">C = terralib.includec("stdio.h")
terra hello(argc : int, argv : &rawstring)
C.printf("Hello world!\n")
return 0
end</syntaxhighlight>
=={{header|Terraform}}==
<syntaxhighlight lang="hcl">output "result" {
value = "Hello world!"
}</syntaxhighlight>
{{Out}}
<pre>$ terraform init
$ terraform apply
Apply complete! Resources: 0 added, 0 changed, 0 destroyed.
Outputs:
result = Hello world!
$ terraform output result
Hello world!</pre>
=={{header|TestML}}==
<syntaxhighlight lang="testml">%TestML 0.1.0
Print("Hello world!")</syntaxhighlight>
=={{header|TI-57}}==
0.7745
You must then turn the calculator upside down to read the text: [https://aerobarfilms.files.wordpress.com/2023/04/ti-57-hello-world-1.jpg screenshot]
=={{header|TI-83 BASIC}}==
<syntaxhighlight lang="ti83b">Disp "Hello world!</syntaxhighlight>
(Lowercase letters DO exist in TI-BASIC, though you need an assembly program to enable them.)
=={{header|TI-89 BASIC}}==
<
=={{header|Tiny BASIC}}==
{{works with|TinyBasic}}
<syntaxhighlight lang="basic">
10 PRINT "Hello, World!"
20 END
</syntaxhighlight>
=={{header|TMG}}==
Unix TMG:
<syntaxhighlight lang="tqs">begin: parse(( = { <Hello, World!> * } ));</syntaxhighlight>
=={{header|TorqueScript}}==
<
=={{header|TPP}}==
<syntaxhighlight lang="tpp">Hello world!</syntaxhighlight>
=={{header|Transact-SQL}}==
<syntaxhighlight lang="sql">PRINT "Hello world!"</syntaxhighlight>
=={{header|Transd}}==
<syntaxhighlight lang="scheme">(textout "Hello, World!")</syntaxhighlight>
=={{header|TransFORTH}}==
<syntaxhighlight lang="forth">PRINT " Hello world! "</syntaxhighlight>
=={{header|Trith}}==
<
=={{header|
<syntaxhighlight lang="truebasic">
! In True BASIC all programs run in their own window. So this is almost a graphical version.
PRINT "Hello world!"
END
</syntaxhighlight>
=={{header|TUSCRIPT}}==
<syntaxhighlight lang="tuscript">
$$ MODE TUSCRIPT
PRINT "Hello world!"
</syntaxhighlight>
Output:
<pre>
Hello world!
</pre>
=={{header|uBasic/4tH}}==
<syntaxhighlight lang="text">Print "Hello world!"</syntaxhighlight>
=={{header|Uniface}}==
<syntaxhighlight lang="uniface">
message "Hello world!"
</syntaxhighlight>
=={{header|Unison}}==
<syntaxhighlight lang="unison">
main = '(printLine "Hello world!")
</syntaxhighlight>
=={{header|UNIX Shell}}==
{{works with|Bourne Shell}}
<syntaxhighlight lang="bash">#!/bin/sh
echo "Hello world!"</syntaxhighlight>
==={{header|C Shell}}===
<syntaxhighlight lang="csh">#!/bin/csh -f
echo "Hello world!\!"</syntaxhighlight>
We use \! to prevent history substitution. Plain ! at end of string seems to be safe, but we use \! to be sure.
=={{header|Unlambda}}==
<
=={{header|Ursa}}==
<syntaxhighlight lang="ursa">out "hello world!" endl console</syntaxhighlight>
=={{header|Ursala}}==
output as a side effect of compilation
<
main = -[
output by a compiled executable
<
#executable ('parameterized','')
main = <file[contents: -[
=={{header|Ursalang}}==
<syntaxhighlight lang="ursa">print("hello woods!")</syntaxhighlight>
=={{header|உயிர்/Uyir}}==
<syntaxhighlight lang="உயிர்/uyir">முதன்மை என்பதின் வகை எண் பணி {{
("உலகத்தோருக்கு வணக்கம்") என்பதை திரை.இடு;
முதன்மை = 0;
}};</syntaxhighlight>
=={{header|Uxntal}}==
<syntaxhighlight lang="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
</syntaxhighlight>
=={{header|V}}==
<
=={{header|Vala}}==
<
stdout.printf("Hello
}</
=={{header|Vale}}==
{{works with|Vale|0.2.0}}
<syntaxhighlight lang="vale">
import stdlib.*;
exported func main() {
println("Hello world!");
}
</syntaxhighlight>
=={{header|VAX Assembly}}==
<syntaxhighlight lang="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
</syntaxhighlight>
=={{header|VBA}}==
<syntaxhighlight lang="vb">
Public Sub hello_world_text
Debug.Print "Hello World!"
End Sub
</syntaxhighlight>
=={{header|VBScript}}==
{{works with|Windows Script Host|5.7}}
<
=={{header|Vedit macro language}}==
<
=={{header|Verbexx}}==
<syntaxhighlight lang="verbexx">@SAY "Hello world!";</syntaxhighlight>
=={{header|Verilog}}==
<syntaxhighlight lang="verilog">
module main;
initial begin
$display("Hello world!");
$finish ;
end
endmodule
</syntaxhighlight>
=={{header|VHDL}}==
<syntaxhighlight lang="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;</syntaxhighlight>
=={{header|Vim Script}}==
<syntaxhighlight lang="vim">echo "Hello world!\n"</syntaxhighlight>
=={{header|Visual Basic}}==
{{Libheader|Microsoft.Scripting}}
{{works with|Visual Basic|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.
<syntaxhighlight lang="vb">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</syntaxhighlight>
=={{header|Visual Basic .NET}}==
<syntaxhighlight lang="vb">Imports System
Module HelloWorld
Sub Main()
Console.WriteLine("Hello world!")
End Sub
End Module</syntaxhighlight>
=={{header|Viua VM assembly}}==
<syntaxhighlight lang="text">.function: main/0
text %1 local "Hello World!"
print %1 local
izero %0 local
return
.end</syntaxhighlight>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (lang)">println('Hello World!')</syntaxhighlight>
=={{header|VTL-2}}==
<syntaxhighlight lang="vtl-2">10 ?="Hello world!"</syntaxhighlight>
=={{header|Waduzitdo}}==
<syntaxhighlight lang="waduzitdo">T:Hello world!
S:</syntaxhighlight>
=={{header|Wart}}==
<syntaxhighlight lang="wart">prn "Hello world!"</syntaxhighlight>
=={{header|WDTE}}==
<syntaxhighlight lang="wdte">io.writeln io.stdout 'Hello world!';</syntaxhighlight>
=={{header|WebAssembly}}==
{{libheader|WASI}}
<syntaxhighlight lang="webassembly">(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
)
)
</syntaxhighlight>
=={{header|Wee Basic}}==
<syntaxhighlight lang="wee basic">print 1 "Hello world!"
end</syntaxhighlight>
=={{header|Whenever}}==
<syntaxhighlight lang="whenever">1 print("Hello world!");</syntaxhighlight>
=={{header|Whiley}}==
<syntaxhighlight lang="whiley">import whiley.lang.System
method main(System.Console console):
console.out.println("Hello world!")</syntaxhighlight>
=={{header|Whitespace}}==
There is a "Hello World" - example-program on the [http://compsoc.dur.ac.uk/whitespace/hworld.ws Whitespace-website]
=={{header|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.
<syntaxhighlight lang="wisp">import : scheme base
scheme write
display "Hello world!"
newline</syntaxhighlight>
=={{header|Wolfram Language}}==
<syntaxhighlight lang="wolfram">Print["Hello world!"]</syntaxhighlight>
=={{header|Wren}}==
<syntaxhighlight lang="wren">System.print("Hello world!")</syntaxhighlight>
=={{header|X10}}==
<syntaxhighlight lang="x10">class HelloWorld {
public static def main(args:Rail[String]):void {
if (args.size < 1) {
Console.OUT.println("Hello world!");
return;
}
}
}</syntaxhighlight>
=={{header|X86 Assembly}}==
Line 1,046 ⟶ 5,045:
This is known to work on Linux, it may or may not work on other Unix-like systems
Prints "
<
msg db '
len equ $-msg
Line 1,061 ⟶ 5,060:
mov ebx, 0
mov eax, 1
int 80h</
'''AT&T syntax:''' works with gcc (version 4.9.2) and gas (version 2.5):
<syntaxhighlight lang="asm">.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"</syntaxhighlight>
=={{header|X86-64 Assembly}}==
===UASM===
<syntaxhighlight lang="asm">
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
</syntaxhighlight>
===AT&T syntax (Gas)===
<syntaxhighlight lang="asm">// 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"</syntaxhighlight>
=={{header|XBasic}}==
{{works with|Windows XBasic}}
<syntaxhighlight lang="xbasic">
PROGRAM "hello"
VERSION "0.0003"
DECLARE FUNCTION Entry()
FUNCTION Entry()
PRINT "Hello World"
END FUNCTION
END PROGRAM
</syntaxhighlight>
=={{header|xEec}}==
<syntaxhighlight lang="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
</syntaxhighlight>
=={{header|XL}}==
<syntaxhighlight lang="xl">use XL.UI.CONSOLE
WriteLn "Hello world!"</syntaxhighlight>
=={{header|XLISP}}==
<syntaxhighlight lang="xlisp">(DISPLAY "Hello world!")
(NEWLINE)</syntaxhighlight>
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">code Text=12;
Text(0, "Hello world!
")</syntaxhighlight>
=={{header|XPath}}==
<syntaxhighlight lang="xpath">'Hello world
'</syntaxhighlight>
=={{header|XSLT}}==
With a literal newline:
<syntaxhighlight lang="xml"><xsl:text>Hello world!
</xsl:text></syntaxhighlight>
Or, with an explicit newline:
<syntaxhighlight lang="xml"><xsl:text>Hello world!
</xsl:text></syntaxhighlight>
=={{header|
<syntaxhighlight lang="yabasic">
print "Hello world!"
</syntaxhighlight>
=={{header|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.
<syntaxhighlight lang="yaml">
!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!":
</syntaxhighlight>
=={{header|Yorick}}==
<
=={{header|Z80 Assembly}}==
Using the Amstrad CPC firmware:
<syntaxhighlight lang="z80">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"</syntaxhighlight>
=={{header|zkl}}==
<syntaxhighlight lang="zkl">println("Hello world!");</syntaxhighlight>
{{omit from|VBA|VBA can't write or output to console}}
=={{header|Zig}}==
'''Works with:''' 0.10.x, 0.11.x, 0.12.0-dev.1389+42d4d07ef
<syntaxhighlight lang="zig">const std = @import("std");
pub fn main() std.fs.File.WriteError!void {
const stdout = std.io.getStdOut();
try stdout.writeAll("Hello world!\n");
}</syntaxhighlight>
=={{header|Zoea}}==
<syntaxhighlight lang="zoea">program: hello_world
output: "Hello world!"</syntaxhighlight>
=={{header|Zoea Visual}}==
[http://zoea.co.uk/examples/zv-rc/Hello_world.png Hello World]
=={{header|Zoomscript}}==
For typing:
<syntaxhighlight lang="zoomscript">print "Hello world!"</syntaxhighlight>
For importing:
¶0¶print "Hello world!"
=={{header|ZX Spectrum Basic}}==
<syntaxhighlight lang="zxbasic">10 print "Hello world!"</syntaxhighlight>
|
Latest revision as of 14:46, 15 July 2024
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Display the string Hello world! on a text console.
- Related tasks
- Hello world/Graphical
- Hello world/Line Printer
- Hello world/Newbie
- Hello world/Newline omission
- Hello world/Standard error
- Hello world/Web server
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
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
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
10 print "Hello world!"
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
#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#
namespace HelloWorld
{
class Program
{
static void Main(string[] args)
{
System.Console.WriteLine("Hello world!");
}
}
}
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.
program-id. hello.
procedure division.
display "Hello world!".
stop run.
Using relaxed compilation rules, the hello program can become a single DISPLAY statement.
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
console.log "Hello world!"
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
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
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
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
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
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+
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
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!");
print('Hello world!');
WScript.Echo("Hello world!");
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
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
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!"
Logo
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
and
.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
(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
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
#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
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.
to
.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
print "Hello world!\n";
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
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
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
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.
(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
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
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
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
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
@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.
(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
select 'Hello world!' text from dual;
SQL>select 'Hello world!' text from dual; TEXT ------------ Hello world!
SQL PL
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.
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
print("Hello world!")
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
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
#!/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
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
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
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
(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
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
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
'
XSLT
With a literal newline:
<xsl:text>Hello world!
</xsl:text>
Or, with an explicit newline:
<xsl:text>Hello world!
</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
Zoomscript
For typing:
print "Hello world!"
For importing:
¶0¶print "Hello world!"
ZX Spectrum Basic
10 print "Hello world!"
- Programming Tasks
- Basic language learning
- Selection/Short Circuit/Console Program Basics
- Simple
- 0815
- 11l
- 360 Assembly
- IBM Z HL/ASM
- 4DOS Batch
- 4ME
- 6502 Assembly
- 6800 Assembly
- 8080 Assembly
- 8086 Assembly
- 8th
- AArch64 Assembly
- ABAP
- ACL2
- Acornsoft Lisp
- Action!
- ActionScript
- Ada
- Agda
- Agena
- Aime
- Algae
- ALGOL 60
- ALGOL 68
- ALGOL W
- ALGOL-M
- Alore
- Amazing Hopper
- AmbientTalk
- AmigaE
- AngelScript
- AntLang
- Anyways
- APL
- AppleScript
- Applesoft BASIC
- Apricot
- Arc
- Arendelle
- Argile
- ARM Assembly
- ArnoldC
- Arturo
- AsciiDots
- Astro
- Asymptote
- Atari BASIC
- ATS
- AutoHotkey
- AutoIt
- AutoLISP
- Avail
- AWK
- Axe
- B
- B4X
- Babel
- BabyCobol
- Bait
- Ballerina
- Bash
- BASIC
- BaCon
- BASIC256
- Batch File
- Battlestar
- BBC BASIC
- Bc
- BCPL
- Beef
- Beeswax
- Befunge
- Binary Lambda Calculus
- Bird
- Blade
- Blast
- BlitzMax
- Blue
- Blz
- BML
- Boo
- BootBASIC
- BQN
- Brace
- Bracmat
- Brainf***
- Brat
- Brlcad
- Bruijn
- Burlesque
- C
- C sharp
- C++
- C++/CLI
- C1R
- C2
- C3
- Casio BASIC
- Cat
- Cduce
- CFEngine
- Chapel
- Chef
- Chipmunk Basic
- ChucK
- Cind
- Clay
- Clean
- Clio
- Clipper
- CLIPS
- CLU
- Clojure
- CMake
- COBOL
- Cobra
- CoffeeScript
- ColdFusion
- Comal
- Comefrom0x10
- Commodore BASIC
- Common Lisp
- Component Pascal
- Coq
- Corescript
- Cowgol
- Crack
- Craft Basic
- Creative Basic
- Crystal
- Curto
- D
- Dafny
- Dao
- Dart
- DataWeave
- DBL
- Dc
- DCL
- DDNC
- Delphi
- DeviousYarn
- DIBOL-11
- Diego
- DIV Games Studio
- DM
- Draco
- Dragon
- DreamBerd
- Dt
- DWScript
- Dyalect
- Dylan
- Dylan.NET
- Déjà Vu
- E
- EasyLang
- EC
- EchoLisp
- ECL
- Ecstasy
- Ed
- EDSAC order code
- Efene
- Egel
- Egison
- EGL
- Eiffel
- WikipediaSourced
- Ela
- Elan
- ElastiC
- Elena
- Elisa
- Elixir
- Elm
- Emacs Lisp
- EMal
- Emojicode
- Enguage
- Erlang
- ERRE
- Euler Math Toolbox
- Extended BrainF***
- Ezhil
- F Sharp
- Factor
- Falcon
- FALSE
- Fantom
- Fe
- Fennel
- Ferite
- Fermat
- Fexl
- Fhidwfe
- Fish
- FOCAL
- Forth
- Fortran
- Fortress
- FreeBASIC
- Free Pascal
- Frege
- Friendly interactive shell
- Frink
- FTCBASIC
- FunL
- Furor
- Peri
- FutureBasic
- FUZE BASIC
- Gambas
- GAP
- GB BASIC
- Gecho
- Gema
- Genie
- Gentee
- GFA Basic
- GLBasic
- Gleam
- Glee
- Global Script
- GlovePIE
- GML
- Go
- Golfscript
- Gosu
- Grain
- Groovy
- GW-BASIC
- Hack
- Halon
- Harbour
- Hare
- Haskell
- Haxe
- Hexiscript
- HicEst
- HLA
- HolyC
- Hoon
- Hopper
- HPPPL
- HQ9+
- HQ9+ examples needing attention
- Examples needing attention
- Huginn
- HTML5
- Hy
- I
- Icon
- Unicon
- IDL
- Idris
- Inform 6
- Inko
- Insitux
- Intercal
- Integer BASIC
- Io
- Ioke
- IS-BASIC
- Isabelle
- IWBASIC
- J
- Jack
- Jacquard Loom
- Jai
- Jakt
- Janet
- Java
- JavaScript
- JCL
- Jinja
- Joy
- Jq
- JSE
- Jsish
- Julia
- K
- Kabap
- Kaya
- Kdf9 Usercode
- Kdf9 examples needing attention
- Keg
- Kite
- Kitten
- KL1
- Koka
- KonsolScript
- Kotlin
- KQL
- KSI
- Lambdatalk
- Lang
- Lang5
- Langur
- Lasso
- LaTeX
- Latitude
- LC3 Assembly
- LDPL
- Lean
- LFE
- Liberty BASIC
- LIL
- Lily
- LilyPond
- Limbo
- Lingo
- Lisaac
- Little
- LiveCode
- LLVM
- Lobster
- Logo
- Logtalk
- LOLCODE
- LotusScript
- LSE
- LSE64
- Lua
- Luna
- M2000 Interpreter
- M4
- MACRO-10
- MACRO-11
- Maclisp
- MAD
- Make
- Malbolge
- MANOOL
- Maple
- Mastermind
- Mathcad
- Mathematica
- Wolfram Language
- MATLAB
- Maude
- Maxima
- MAXScript
- MDL
- MEL
- MelonBasic
- Mercury
- Metafont
- Microsoft Small Basic
- Min
- Minimal BASIC
- MiniScript
- MiniZinc
- MIPS Assembly
- Miranda
- MIRC Scripting Language
- ML/I
- Modula-2
- TopSpeed Modula-2
- Modula-3
- MontiLang
- Morfa
- Mosaic
- MSX Basic
- MUF
- MUMPS
- MyDef
- MyrtleScript
- MySQL
- Mythryl
- N/t/roff
- Nanoquery
- Neat
- Neko
- Nemerle
- NetRexx
- Never
- NewLISP
- Nickle
- Nim
- Nit
- Nix
- NLP++
- NS-HUBASIC
- Nu
- Nutt
- Nyquist
- Nyquist Version 3.15
- Oberon-2
- Objeck
- ObjectIcon
- Objective-C
- OCaml
- Occam
- Octave
- Odin
- Oforth
- Ol
- Onyx
- Onyx (wasm)
- OOC
- OoRexx
- OpenLisp
- Openscad
- Owl Lisp
- Oxygene
- Oz
- PARI/GP
- Pascal
- PascalABC.NET
- PASM
- PDP-1 Assembly
- PDP-11 Assembly
- Pebble
- PepsiScript
- Perl
- Peylang
- Pharo
- Phix
- Phix/basics
- PHL
- PHP
- Picat
- PicoLisp
- Pict
- Pikachu
- Pike
- PILOT
- PIR
- Pixilang
- PL/I
- PL/M
- PL/SQL
- Plain English
- Plan
- Pointless
- Pony
- Pop11
- Portugol
- PostScript
- Potion
- PowerBASIC
- PowerShell
- Processing
- ProDOS
- Programming Language
- ProgressBASIC
- Prolog
- PROMAL
- PSQL
- Pure
- PureBasic
- Python
- QB64
- Quackery
- Quill
- Quite BASIC
- R
- Ra
- Racket
- Raku
- Raven
- RATFOR
- RASEL
- REALbasic
- REBOL
- RED
- Refal
- Relation
- ReScript
- Retro
- REXX
- Rhovas
- Ring
- RISC-V Assembly
- Roc
- Rockstar
- RPG
- RPL
- RTL/2
- Ruby
- Run BASIC
- Rust
- Salmon
- SAS
- SASL
- Sather
- Scala
- Console
- Scheme
- Scilab
- ScratchScript
- Sed
- Seed7
- Self
- SenseTalk
- Set lang
- SETL
- SETL4
- Shen
- Shiny
- Sidef
- SimpleCode
- SIMPOL
- Simula
- Sing
- Sisal
- Skew
- SkookumScript
- Slate
- Slope
- SmallBASIC
- Smalltalk
- Smart BASIC
- SmileBASIC
- SNOBOL4
- SNUSP
- Soda
- SoneKing Assembly
- SPARC Assembly
- Sparkling
- SPL
- SQL
- SQL PL
- Standard ML
- Stata
- Suneido
- Swahili
- Swift
- Symstatic
- Symsyn
- TailDot
- Tailspin
- Tcl
- Teco
- Tern
- Terra
- Terraform
- TestML
- TI-57
- TI-83 BASIC
- TI-89 BASIC
- Tiny BASIC
- TMG
- TorqueScript
- TPP
- Transact-SQL
- Transd
- TransFORTH
- Trith
- True BASIC
- TUSCRIPT
- UBasic/4tH
- Uniface
- Unison
- UNIX Shell
- C Shell
- Unlambda
- Ursa
- Ursala
- Ursalang
- உயிர்/Uyir
- Uxntal
- V
- Vala
- Vale
- VAX Assembly
- VBA
- VBScript
- Vedit macro language
- Verbexx
- Verilog
- VHDL
- Vim Script
- Visual Basic
- Microsoft.Scripting
- Visual Basic .NET
- Viua VM assembly
- V (Vlang)
- VTL-2
- Waduzitdo
- Wart
- WDTE
- WebAssembly
- WASI
- Wee Basic
- Whenever
- Whiley
- Whitespace
- Wisp
- Wren
- X10
- X86 Assembly
- X86-64 Assembly
- XBasic
- XEec
- XL
- XLISP
- XPL0
- XPath
- XSLT
- Yabasic
- YAMLScript
- Yorick
- Z80 Assembly
- Zkl
- VBA/Omit
- Zig
- Zoea
- Zoea Visual
- Zoomscript
- ZX Spectrum Basic
- Pages with too many expensive parser function calls