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

MVS

HELLO    CSECT          USING HELLO,15         LA    1,MSGAREA     Point Register 1 to message area         SVC   35            Invoke SVC 35 (Write to Operator)          BR    14            ReturnMSGAREA  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

         WTO   'Hello world!'         BR    14            Return         END

VM/CMS

HELLO    CSECT                        BASR 12,0                    USING *,12                   WRTERM 'HELLO WORLD'         BR 14                        END

4DOS Batch

echo Hello world!

4ME

Normal 4ME

Rewriten 4ME

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..codeldx#0; Starting index 0 in X register.printnext:ldatext,x; Get character from string.beqdone; If we read a 0 we're done.jsrbsout; Output character.inx; Increment index to next character.bneprintnext; Repeat if index doesn't overflow to 0.done:rts; Return from subroutine..rodatatext:.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 itouts    jsr  outeee     ;Emit a as ascii        inx             ;Advance the string pointerputs    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.org100h; CP/M .COM entry point is 100h - like DOSmvic,9; C holds the syscall, 9 = print string - like DOSlxid,msg; DE holds a pointer to the stringjmp5; 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.DATATXT DB "Hello world!$".CODESTART:MOV ax, @DATAMOV ds, axMOV ah, 09h; prepare output functionMOV dx, OFFSET TXT; set offsetINT 21h; output string TXTMOV AX, 4C00h ; go back to DOSINT 21hEND START

8th

"Helloworld!\n".bye

AArch64 Assembly

.equSTDOUT,1.equSVC_WRITE,64.equSVC_EXIT,93.text.global_start_start:stpx29,x30,[sp,-16]!movx0,#STDOUTldrx1,=msgmovx2,13movx8,#SVC_WRITEmovx29,spsvc#0// write(stdout, msg, 13);ldpx29,x30,[sp],16movx0,#0movx8,#SVC_EXITsvc#0// exit(0);msg:.ascii"Hello World!\n".align4

.global_start.text_start:movx8,#64//64 is writemovx0,#1//1 is stdoutadrx1,msg//mov address of msg into x1movx2,#(msgend - msg) //msgend minus msg is the length of messagesvc#0//system callmovx8,#93//93 is exitmovx0,xzr//0 is the exit code. xzr is the zero registersvc#0//system callmsg:.ascii"Hello world!\n"msgend:.align4

.global_start.text_start:adrx0,msg// load x0 with address of messageblwritez// call the function that writes null-terminated string to stdoutmovx8,#93// 93 is syscall exitmovx0,xzr// exit code = 0. Exit normal.svc#0// syscall// If using as a function in C declare it aswritez:// extern long writez(char *str);movx1,x0// address of str needs to be in x1 for syscallsubx0,x0,#1// decrement x0, because the next statement increments it.0:ldrbw2,[x0,#1]!// increment x0, load byte value at x0 in w2cbnzw2,0b// if w2 is not zero jump back to 0: labelsubx2,x0,x1// subtract x1 from x0, load into x2. length of strmovx0,#1// mov into x0 1. stdoutmovx8,#64// mov into x8 64. writesvc#0// syscallret// return from function.// return value (x0) is number of characters written.msg:.asciz"Hello world!\n"// .asciz means null-terminated string. Assembler adds the 0.align4

ABAP

REPORTzgoodbyeworld.WRITE'Hello world!'.

ACL2

(cw"Hello world!~%")

Acornsoft Lisp

(printc'Hello!world!!)

Action!

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

ActionScript

trace("Hello world!");

Ada

withAda.Text_IO;useAda.Text_IO;procedureMainisbeginPut_Line("Hello world!");endMain;

Adina

вывести/перенос «Hello world!»

english()displayln "Hello world!"

Agda

moduleHelloWorldwhereopenimportAgda.Builtin.IOusing(IO)openimportAgda.Builtin.Unitrenaming(⊤toUnit)openimportAgda.Builtin.Stringusing(String)postulateputStrLn:String->IOUnit{-# FOREIGN GHC import qualified Data.Text as T #-}{-# COMPILE GHC putStrLn = putStrLn . T.unpack #-}main:IOUnitmain=putStrLn"Hello world!"

Agena

print( "Hello world!" )

Aime

o_text("Hello world!\n");

integermain(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

main:   {"Hello world!\n"}printexit(0)

#include <hopper.h>main:   exit("Hello world!\n")

main:  {"Hello world!\n"}return

AmbientTalk

system.println("Hello world!")

AmigaE

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

AngelScript

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

AntLang

echo["Hello, World!"]

Anyways

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

APL

'Hello world!'

AppleScript

"Hello world!"

log"Hello world!"

Applesoft BASIC

 PRINT "Hello world!"

Apricot

(puts "Hello world!")

Arc

(prn "Hello world!")

Arendelle

Aria

func main() {    println("Hello World!");}

ArkScript

(print "Hello world!")

Argile

use stdprint "Hello world!"

ARM Assembly

.global mainmessage:    .asciz "Hello world!\n"    .align 4main:    ldr r0, =message    bl printf    mov r7, #1    swi 0

ArnoldC

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

Arturo

print"Hello world!"

Output:

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

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

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

SendInputHelloworld!{!}

AutoIt

ConsoleWrite("Hello world!"&@CRLF)

AutoLISP

(print"Hello World!")

Avail

Print: "Hello World!";

AWK

BEGIN{print"Hello world!"}

END{print"Hello world!"}

//  {print"Hello world!"exit}

//  {print"Hello world!"}

//

Axe

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.IDENTIFICATIONDIVISION.PROGRAM-ID.USEROUTPUT.PROCEDUREDIVISION.DISPLAYHELLOWORLD.

Bait

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

Ballerina

importballerina/io;publicfunctionmain(){io:println("Hello World!");}

Output:

bash

echo"Hello world!"

BASIC

10print"Hello world!"

PRINT"Hello world!"

BASIC256

PRINT "Hello world!"

Batch File

echo Hello world!

setlocal enableDelayedExpansionecho Hello world^^!

Using%=ExitCodeAscii%

@echo offsetlocal enableextensionscall:char 72call:char 101call:char 108call:char 108call:char 111call:spacecall:char 119call:char 111call:char 114call:char 108call:char 100call:char 33exit /b 0:space:: https://stackoverflow.com/a/9865960:: https://stackoverflow.com/a/31396993for/f%%Ain('"prompt $H &echo on &for%%B in (1) do rem"')do<nulset/p=".%%A "goto:eof:charcmd /c exit%1<nulset/p=%=ExitCodeAscii%goto:eof

Battlestar

consthello="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

UsingSystem;namespaceHelloWorld{classProgram{staticvoidMain(){Console.Writeln("Hello World!");}}}

beeswax

*`Hello, World!

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

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

Befunge

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

Binary Lambda Calculus

Bird

use Consoledefine Main    Console.Println "Hello world"end

Blade

echo 'Hello world!'

print('Hello world!')

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

Blast

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

BlitzMax

print"Hello world!"

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 ;

blz

print("Hello world!")

BML

display "Hello world!"

Boo

print"Hello world!"

bootBASIC

10print"Hello world!"

BQN

•Out"Hello world!"

Brace

#!/usr/bin/env bxuse bMain:say("Hello world!")

Bracmat

put$"Hello world!"

Brainf***

++++++++++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<+++.---.

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

Brat

p "Hello world!"

Brlcad

echo Hello world!

Bruijn

main ["Hello world!"]

Burlesque

"Hello world!"sh

C

C89

#include<stdio.h>intmain(){printf("\nHello world!");return0;}

#include<stdio.h>intmain(){returnprintf("\nHello World!");}

C11

#include<stdlib.h>#include<stdio.h>intmain(void){printf("Hello world!\n");returnEXIT_SUCCESS;}

C23

#include<stdlib.h>#include<stdio.h>intmain(void){puts("Hello world!");returnEXIT_SUCCESS;}

C#

namespaceHelloWorld{classProgram{staticvoidMain(string[]args){System.Console.WriteLine("Hello world!");}}}

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

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

C++

#include<iostream>intmain(){std::cout<<"Hello world!\n";}

importmodulestd;// here does the same thing as #include <print>intmain(){std::print("Hello world!\n");}

C++/CLI

usingnamespaceSystem;intmain(){Console::WriteLine("Hello world!");}

C1R

Hello_world/Text

Output:

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

Calcscript

Casio BASIC

Locate 1,1,"Hello World!"

"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.bundleagentmain{reports:"Hello world!";}

Chapel

writeln("Hello world!");

Chef

Goodbye World Souffle. Ingredients.71 g green beans111 cups oil98 g butter121 ml yogurt101 eggs44 g wheat flour32 zucchinis119 ml water114 g red salmon108 g lard100 g dijon mustard33 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

10print"Hello world!"

ChucK

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

Cind

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

CJam

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

COBOL

program-id.hello.proceduredivision.display"Hello world!".stoprun.

display"Hello, world".

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

10printchr$(147);chr$(14);:REM147=clearscreen,14=switchtolowercasemode20print"Hello world!"30end

Output:

Common Lisp

(formatt"Hello world!~%")

(print"Hello world!")

Alternate solution

;; Project : Hello world/Text(formatt"~a""Hello world!")

Component Pascal

MODULEHello;IMPORTOut;PROCEDUREDo*;BEGINOut.String("Hello world!");Out.LnENDDo;ENDHello.

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

OPENCONSOLEPRINT"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$<>""CLOSECONSOLEEND

Crystal

puts"Hello world!"

Curto

." Hola, mundo!"

D

importstd.stdio;voidmain(){writeln("Hello world!");}

Dafny

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

Dao

io.writeln( 'Hello world!' )

Dart

main(){varbye='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 1END

Dc

[Hello world!]p

5735816763073014741799356604682 P

DCL

$writesys$output"Hello world!"

DDNC

0 111 100 15 110 15 120 31 130 47 140 59 150 125 160 3 170 0 180 63 190 15 200 12 210 36 220 31 230 17 240 500 30 10 20 15 560 42 2 180 172 330 231 562 561 464

Delphi

programProjectGoodbye;{$APPTYPE CONSOLE}beginWriteLn('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

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

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

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

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

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

with_printer()_text(Hello World!);

DIV Games Studio

PROGRAM HELLOWORLD;BEGIN    WRITE_TEXT(0,160,100,4,"HELLO WORLD!");    LOOP        FRAME;    ENDEND

DM

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

Draco

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

Dragon

showln "Hello world!"

Dragonstone

echo "Hello world!"

DreamBerd

print "Hello world!"!

dt

"Hello world!" pl

DuckDB

#Turnofftabularoutput:.modelist.headersoffselect'Hello world!';

Output:

DWScript

PrintLn('Hello world!');

Dyalect

print("Hello world!")

Dylan

module:hello-worldformat-out("%s\n","Hello world!");

Dylan.NET

Console::WriteLine("Hello world!")

//compile using the new dylan.NET v, 11.5.1.2 or later//use mono to run the compiler#refstdasm mscorlib.dllimport Systemassembly helloworld exever 1.2.0.0class public Program   method public static void main()      Console::WriteLine("Hello world!")   end methodend class

Déjà Vu

!print "Hello world!"

E

println("Hello world!")stdout.println("Hello world!")

EasyLang

print "Hello world!"

eC

classGoodByeApp:Application{voidMain(){PrintLn("Hello world!");}}

EchoLisp

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

ECL

OUTPUT('Hello world!');

Ecstasy

moduleHelloWorld{voidrun(){@InjectConsoleconsole;console.print("Hello, World!");}}

Ed

aHello World!.pQ

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 ]EFLFLFOF!F    [ Space character ]WFOFRFLFDFEZPF  [ Start program beginning at        the load point ]

Output:

Efene

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

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

Eiffel

classHELLO_WORLDcreatemakefeaturemakedoprint("Hello world!%N")endend

Ela

open monad iodo putStrLn "Hello world!" ::: IO

Elan

putline ("Hello, world!");

elastiC

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

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

Elisa

 "Hello world!"?

Elixir

IO.puts"Hello world!"

Elm

main=text"Goodbye World!"

Emacs Lisp

(message"Hello world!")

(princ"Hello world!\n")

EMal

writeLine("Hello world!")

Emojicode

🏁 🍇  😀 🔤Hello world!🔤🍉

Enguage

Erlang

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

ERRE

! Hello World in ERRE languagePROGRAM HELLOBEGIN  PRINT("Hello world!")END PROGRAM

Euler Math Toolbox

Extended BrainF***

[.>]@Hello world!

Extended Color BASIC

PRINT "HELLO WORLD!"

Ezhil

F#

printfn "%s" "Hello world!"

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

Factor

"Hello world!" print

Falcon

printl("Hello world!")

> "Hello world!"

FALSE

"Hello world!"

Fantom

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

Fe

(print "Hello World")

Fennel

(print "Hello World")

ferite

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

Fermat

!!'Hello, World!';

Fexl

say "Hello world!"

Fhidwfe

puts$ "Hello, world!\n"

Fish

!v"Hello world!"r! >l?!;o

FOCAL

TYPE "Hello, world" !

Forth

." Hello world!"

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

Fortran

print *,"Hello world!"

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

write (89,100) "Hello world!"

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 wheremain _ = println "Hello world!"

friendly interactive shell

echo Hello world!

Frink

println["Hello world!"]

FTCBASIC

print "Hello, world!"pauseend

FuncSug

displayNewMessage('Hello, world!')

print('Hello, world!')

FunL

println( 'Hello world!' )

Furor

."Hello, World!\n"

FutureBasic

window 1print @"Hello world!"HandleEvents

FUZE BASIC

PRINT "Hello world!"

Gambas

Public Sub Main()PRINT "Hello world!" End

GAP

# Several ways to do it"Hello world!";Print("Hello world!\n"); # No EOL appendedDisplay("Hello world!");f := OutputTextUser();WriteLine(f, "Hello world!\n");CloseStream(f);

GB BASIC

10 print "Hello world!"

gecho

'Hello, <> 'World! print

Gema

*= ! 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/iopub fn main() {    io.println("Hello world!")}

Glee

"Hello world!"

'Hello world!'

 '"Goodbye,World!"'

 "'Goodbye,World!'"

Global Script

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

GlovePIE

debug="Hello world!"

GML

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

Go

package mainimport "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

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;

Hobbes

putStrLn("Hello world!")

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:

HPPPL

PRINT("Hello world!");

HQ9+

H

Huginn

#! /bin/shexec huginn --no-argv -E "${0}" "${@}"#! huginnmain() {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!")}

IBM 1620 SPS

     START WATYHELLO           H     HELLO DAC 12,HELLO WORLD@           DENDSTART

IBM Z HL/ASM

        PRINT ON,GEN,DATAHELLO   CSECTHELLO   RMODE ANYHELLO   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=LBPXWRTL EQU *-BPXWRTSHW      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  FRECSIZE EQU RECEND-*REC     DS CL80RECEND  EQU *RECA    DS  ABPXWRTD DS  CL(BPXWRTL)ALET    DS  FRECL    DS  FRV      DS  FRC      DS  FRN      DS  FDYNL EQU *-DYNAREA*** End of working storage*** Equates*R0      EQU 0R1      EQU 1R2      EQU 2R3      EQU 3R4      EQU 4R5      EQU 5R6      EQU 6R7      EQU 7R8      EQU 8R9      EQU 9R10     EQU 10R11     EQU 11R12     EQU 12R13     EQU 13R14     EQU 14R15     EQU 15        END

Icon andUnicon

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

IDL

print,'Hello world!'

Idris

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

Inform 6

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

Inko

import std::stdio::stdoutstdout.print('Hello, world!')

Insitux

(print "Hello, world!")

Intercal

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

Integer BASIC

   10 PRINT "Hello world!"   20 END

Io

"Hello world!" println

Ioke

"Hello world!" println

IS-BASIC

PRINT "Hello world!"

Isabelle

theory Scratch  imports Mainbegin  value ‹''Hello world!''›end

IWBASIC

OPENCONSOLEPRINT"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$<>""CLOSECONSOLEEND

J

   'Hello world!'Hello world!

   [data=. 'Hello world!'Hello world!   dataHello world!   smoutput dataHello 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 integers0 1 23 4 5   verb_with_infinite_rank =: 'Hello world!'"_   verb_with_infinite_rank i. 2 3Hello world!      verb_with_atomic_rank =: 'Hello world!'"0   verb_with_atomic_rank i. 2 3Hello 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

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

Jactl

print 'Hello'println 'World'

def x = 'Hello'println "$x World"println "There are ${60 * 60 * 24} seconds in a day"

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 Templateprint(Template("Hello World!").render())

from jinja2 import Templateprint(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!"

`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

"#!/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!")}

fun main()  "Hello world!".println

Komodo

println("Hello world!")

KonsolScript

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

Kotlin

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

KQL

print 'Hello world!'

KSI

`plain'Hello world!' #echo #

Labyrinth

Lambdatalk

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

Lang

fn.println(Hello world!)

Lang5

"Hello world!\n" .

langur

writeln "Hello"

Lasso

'Hello world!'

LaTeX

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

Latitude

putln "Hello world!".

LC3 Assembly

.orig x3000LEA R0, hello    ; R0 = &helloTRAP x22         ; PUTS (print char array at addr in R0)HALThello .stringz "Hello World!".end

.orig x3000LEA R1, hello        ; R1 = &helloTOP LDR R0, R1, #0   ; R0 = R1[0]BRz END              ; if R0 is string terminator (x0000) go to ENDTRAP x21             ; else OUT (write char in R0)ADD R1, R1, #1       ;      increment R1BR TOP               ;      go to TOPEND HALThello .stringz "Hello World!".end

LDPL

procedure:display "Hello World!" crlf

Lean

#eval "Hello world!"

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

print("Hello world!")

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

trace("Hello world!")

Lisaac

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

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

puts("Hello world!");

puts(nonewline: "Hello world!");

puts(stderr, "Hello world!");

LiveCode

put "Hello World!"

Answer "Hello World!"

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

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` methoddeclare i32 @puts(i8*) nounwinddefine i32 @main(){  call i32 @puts( i8* getelementptr ([14 x i8], [14 x i8]* @str, i32 0,i32 0))  ret i32 0}

Lobster

print "Hello world!"

Logo

print [Hello world!]

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

HAICAN 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

print "Hello world!"

 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

module HelloWorld {    print "Hello World!"}HelloWorld

M4

`Hello world!'

MACRO-10

        TITLE HELLOCOMMENT !  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!~%")

(print "Hello world!")

MAD

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

make

all:$(info Hello world!)

Malbolge

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

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

Output:

MANOOL

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

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

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

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

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

Maple

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

MariaDB

SELECT 'Hello world!' AS greeting;VALUES ('Hello world!');

Mastermind

output "Hello world!\n";

Mathcad

"Hello, World!"

Mathematica /Wolfram Language

Print["Hello world!"]

MATLAB

>> disp('Hello world!')

Maude

fmod BYE-WORLD isprotecting STRING .op sayBye : -> String .eq sayBye = "Hello world!" .endfmred sayBye .

Maxima

print("Hello world!");

MAXScript

print "Hello world!"

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:

MIPS Assembly

   .data #section for declaring variableshello:  .asciiz "Hello world!" #asciiz automatically adds the null terminator. If it's .ascii it doesn't have it.   .text # beginning of codemain: # 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.WriteLnEND Hello.

TopSpeed Modula-2

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 .

MoonBit

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

Morfa

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

Mosaic

proc main =    println "Hello, world"end

println "Hello, world"

MSX Basic

10 PRINT "Hello world!"

MUF

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

MUMPS

Write "Hello world!",!

MyDef

$print Hello world

module: c$print Hello world

module: python$print Hello world

module: js$print "Hello world"

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

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

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

NetRexx

say  'Hello world!'

Never

func main() -> int {    prints("Hello world!\n");    0}

Output:

newLISP

(println "Hello world!")

Nickle

printf("Hello world!\n")

Nim

echo("Hello world!")

stdout.writeLine("Hello World!")

Nit

print "Hello world!"

Nix

"Hello world!"

NLP++

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

Nom

begin { add 'hello world'; print; quit; }

NS-HUBASIC

10 ? "HELLO WORLD!"

10 PRINT "HELLO WORLD!"

Nu

print "Hello world!"

Nutt

module hello_worldimports native.io.output.saysay("Hello, world!")end

Nyquist

LISP syntax

(format t "Hello world!")

(print "Hello world!")

SAL syntax

print "Hello World!"

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 ioprocedure main ()  io.write ("Hello world!")end

Output:

Objective-C

#import <Foundation/Foundation.h>int main() {    @autoreleasepool {        NSLog(@"Hello, World!");    }}

#import <Foundation/Foundation.h>int main() {    @autoreleasepool {        NSFileHandle *standardOutput = [NSFileHandle fileHandleWithStandardOutput];        NSString *message = @"Hello, World!\n";        [standardOutput writeData:[message dataUsingEncoding:NSUTF8StringEncoding]];    }}

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

printf("Hello world!");

Odin

package mainimport "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:

OOC

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

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

ooRexx

/* Rexx */say 'Hello world!'

OpenLisp

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

Openscad

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

OPL

PROC main:    PRINT "Hello, world!"    GETENDP

Owl Lisp

(print "Hello world!")

Output:

Oxygene

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

Output:

OxygenBasic

print "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., 2023begin  System.Console.WriteLine('Hello World!');end.

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

##println('Hello World!');

Output:

PASM

print "Hello world!\n"end

PDP-1 Assembly

hello   / above: title line - was punched in human readable letters on paper tape/ below: location specifier - told assembler what address to assemble to100/lup,lac i ptr/ load ac from address stored in pointercli/ clear io registerlu2,rcl 6s/ rotate combined ac + io reg 6 bits to the left/ left 6 bits in ac move into right 6 bits of io regtyo/ type out character in 6 right-most bits of io regsza/ skip next instr if accumulator is zerojmp lu2/ otherwise do next character in current wordidx ptr/ increment pointer to next word in messagesas end/ skip next instr if pointer passes the end of messagejmp lup/ otherwise do next word in messagehlt/ halt machineptr,msg/ pointer to current word in messagemsg,text "hello, world"/ 3 6-bit fiodec chars packed into each 18-bit wordend,.         / sentinel for end of messagestart 100/ tells assembler where program starts

PDP-11 Assembly

.globl  start.textstart:        mov$1,r0               / r0=stream, STDOUT=$1sys4; outtext; outlen  / sys 4 is writesys1                   / sys 1 is exitrtspc                  / in case exit returns.dataouttext: <Hello world!\n>outlen = . - outtext

Pebble

;Hello world example program;for x86 DOS;compile with Pebble;compiled com program is 51 bytesprogram examples\hellobeginecho "Hello, world!"pausekillend

PepsiScript

#include default-libraries#author Childishbeatclass Hello world/Text:function Hello world/Text:print "Hello world!"end

Peri

."Hello, World!\n"

Perl

print "Hello world!\n";

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

use 5.010;say 'Hello world!';

Peylang

chaap 'Hello world!';

Output:

Pharo

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

Phix

PHL

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

PHP

<?phpecho "Hello world!\n";?>

Hello world!

Picat

println("Hello, world!")

PicoLisp

(prinl "Hello world!")

Pico-8

print("hello, world!")

? 'hello, world!'

Pict

(prNL "Hello World!");

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 pikachupikachu pikachu pi pikachupikachu 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 pikachupikachu pikachu pi pikachupikachu 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 pikachupi pikapikachu pikachu pi pikachupika pipikachu pikachu pi pikachupikachu 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 pikachupi pikapikachu pikachu pi pikachupikachu 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 pikachupikachu pikachu pi pikachupikachu 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 pikachupikachu pikachu pika pikachupikachu pikachu pika pikachupi 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 pikachupikachu pikachu pi pikachupikachu 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 pikachupikachu 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 pikachupikachu pikachu pi pikachupikachu pikachu pika pikachu

Pike

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

PILOT

T:Hello world!

PIR

.sub hello_world_text :mainprint "Hello world!\n".end

Pixilang

fputs("Hello world!\n")

PL/I

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

PL/M

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 onBEGIN  DBMS_OUTPUT.PUT_LINE('Hello world!');END;/

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

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

Pluto

print "Hello world!"

Pointless

output = println("Hello world!")

Pony

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

Pop11

printf('Hello world!\n');

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

PostScript

%!PS/Helvetica 20 selectfont70 700 moveto(Hello world!) showshowpage

(Hello world!) ==

(Hello world!) =

(Hello world!) print

%!PS/Helvetica 20 selectfont70 700 moveto(Hello world!) dup dup dup= print == % prints three times to the consoleshow % prints to document1 0 div % provokes error messageshowpage

Potion

"Hello world!\n" print

PowerBASIC

#COMPILE EXE#COMPILER PBCC 6FUNCTION PBMAIN () AS LONG  CON.PRINT "Hello world!"  CON.WAITKEY$END FUNCTION

PowerShell

'Hello world!'

Processing

println("Hello world!");

ProDOS

printline Hello world!

Programming Language

print(Hello world!)

ProgressBASIC

Prolog

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

PROMAL

program helloinclude librarybeginoutput "Hello world!"end

PSQL

Pure

using system;puts "Hello world!\n" ;

PureBasic

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

Debug("Hello world!")

Python

print "Hello world!"

import syssys.stdout.write("Hello world!\n")

print("Hello world!")

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

 message("Hello world!")

 print("Hello world!")

Ra

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

Racket

(printf "Hello world!\n")

Raku

say 'Hello world!';

"Hello, World!".say();

Raven

'Hello world!' print

RATFOR

program hellowrite(*,101)"Hello World"101 format(A)end

RASEL

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

REALbasic

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

Rebol

print "Hello world!"

RED

print "Hello world!"

Refal

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

Relation

' Hello world!

ReScript

Js.log("Hello world!")

Output:

Retro

'Hello_world! s:put nl

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

Rhombus

print("Hello world!")

Rhovas

print("Hello world!");

Ring

See "Hello world!"

RISC-V Assembly

.datahello:.string "Hello World!\n\0".textmain:la a0, helloli a7, 4ecallli a7, 10ecall

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 pfmain =    Stdout.line "I'm a Roc application!"

Rockstar

Shout "Hello world!"

Rocq

Require Import Coq.Strings.String.Eval compute in ("Hello world!"%string).

RPG

RPL

Output:

RTL/2

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

Ruby

puts "Hello world!"

$stdout.puts "Hello world!"

 STDOUT.write "Hello world!\n"

$>.puts "Hello world!"

$>.write "Hello world!\n"

Run BASIC

print "Hello world!"

Rust

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

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

Rye

print "Hello world!"

Salmon

"Hello world!"!

print("Hello world!\n");

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

SapbotVM

[    "DEBUG;THello, World!"]

# Simple Hello World program in SVM2 format10 DEBUG;Thello World

SAS

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

SASL

'Hello World!",nl

Sather

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

Scala

Ad hoc REPL solution

println("Hello world!")

Via Java runtime

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

Via Scala Console API

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

"Hello world!"

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

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 ! Hset ! Eset ! Lset ! Lset ! Oset ! 32set ! Wset ! Oset ! Rset ! Lset ! Dset ! 33

SETL

print("Hello world!");

SETL4

out("Hello world!");end

Shen

(output "Hello world!~%")

Shiny

say 'Hello world!'

Sidef

„Hello world!”.say;

SIL

printLine Hello world!

SimpleCode

dtxtHello world!

SIMPOL

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

Simula

BEGIN   OUTTEXT("Hello world!");   OUTIMAGEEND

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

@entrydef main {  dynamic.console.log("Hello world!")}

SkookumScript

print("Hello world!")

"Hello world!"

Slate

inform: 'Hello world!'.

Slope

(write "Hello, world!")

SmallBASIC

PRINT "Hello world!"

Smalltalk

Transcript show: 'Hello world!'; cr.

'Hello world!' printNl.

smart BASIC

PRINT "Hello world!"

SmileBASIC

PRINT "Hello world!"

SNOBOL4

    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 printdv Msg Goodbye,World!mov eax Msgpushcall printpop

SPARC Assembly

.section".text".global_start_start:mov4,%g1! 4 is SYS_writemov1,%o0! 1 is stdoutset.msg,%o1! pointer to buffermov(.msgend-.msg),%o2! lengthta8mov1,%g1! 1 is SYS_exitclr%o0! return status is 0ta8.msg:.ascii"Hello world!\n".msgend:

Sparkling

print("Hello world!");

SPL

#.output("Hello world!")

SQL

select 'Hello world!' text from dual;

SQL PL

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

SET SERVEROUTPUT ON;CALL DBMS_OUTPUT.PUT_LINE('Hello world!');

Standard ML

print "Hello world!\n"

Stata

display "Hello world!"

Stax

Suneido

Print("Hello world!")

Swahili

andika("Hello world!")

Swift

print("Hello world!")

println("Hello world!")

Symsyn

 'hello world' []

TailDot

c,x,Hello World!,v,x

Tailspin

'Hello World' -> !OUT::write

'Hello World' !

TAV

 \( The famous example \) main (parms):+   print "Greetings from TAV"

Tcl

puts stdout {Hello world!}

puts $fileID {Hello world!}

Teco

^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 0end

Terraform

output "result" {  value = "Hello world!"}

Output:

TestML

%TestML 0.1.0Print("Hello world!")

TI-57

TI-83 BASIC

Disp "Hello world!

TI-89 BASIC

Disp "Hello world!"

Tiny BASIC

10 PRINT "Hello, World!"20 END

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

uBasic/4tH

Print "Hello world!"

Uiua

Uniface

message "Hello world!"

Unison

main = '(printLine "Hello world!")

UNIX Shell

#!/bin/shecho "Hello world!"

C Shell

#!/bin/csh -fecho "Hello world!\!"

Unlambda

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

Ursa

out "hello world!" endl console

Ursala

#show+main = -[Hello world!]-

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

Ursalang

print("hello woods!")

உயிர்/Uyir

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

Uxntal

|10 @Console &vector $2 &read $1 &pad $5 &write $1 &error $1|100@on-reset ( -> );my-string print-textBRK@print-text ( str* -- )&whileLDAk .Console/write DEOINC2 LDAk ?&whilePOP2JMP2r@my-string"Hello 20 "World! 0a00

Output:

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

VHDL

LIBRARY std;USE std.TEXTIO.all;entity test isend entity test;architecture beh of test isbegin  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

Option ExplicitPrivate Declare Function AllocConsole Lib "kernel32.dll" () As LongPrivate 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 FreeConsoleEnd Sub

Visual Basic .NET

Imports SystemModule HelloWorld    Sub Main()        Console.WriteLine("Hello world!")    End SubEnd 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.Systemmethod main(System.Console console):    console.out.println("Hello world!")

Whitespace

Wisp

import : scheme base         scheme writedisplay "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

section .datamsg     db      'Hello world!', 0AHlen     equ     $-msgsection .textglobal  _start_start: mov     edx, len        mov     ecx, msg        mov     ebx, 1        mov     eax, 4        int     80h        mov     ebx, 0        mov     eax, 1        int     80h

.section .text.globl mainmain:movl $4,%eax#syscall number 4movl $1,%ebx#number 1 for stdoutmovl $str,%ecx#string pointermovl $16,%edx#number of bytesint $0x80#syscall interruptret.section .datastr: .ascii "Hello world!\12"

X86-64 Assembly

UASM

option casemap:noneif @Platform eq 1   option dllimport:<kernel32>      ExitProcess   proto :dword   option dllimport:none      exit          equ ExitProcessendifprintf              proto :qword, :varargexit                proto :dword.codemain procinvoke printf, CSTR("Goodbye, World!",10)invoke exit, 0retmain endpend

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)    .datamessage:    .ascii "Hello, world!\n"

NASM

; compile with:; nasm -f elf64 hello0.asm -o hello0.o; ld hello0.o -o hello0 -z noexecstack -no-pie -sglobal _startsection .text_start: .write:    mov    rax,    1    mov    rdi,    1    mov    rsi,    message    mov    rdx,    14    syscall .exit:    mov    rax,    60    xor    rdi,    rdi    syscallsection .datamessage: db "Hello, World!", 0x0a

; compile with:; nasm -f elf64 hello1.asm -o hello1.o; gcc hello1.o -o hello1 -z noexecstack -no-pie -s; or; tcc hello1.o -o hello1global mainextern putssection .textmain:    mov    rdi,    message    sub    rsp,    8    call   puts    add    rsp,    8    xor    rax,    rax    retsection .datamessage: db "Hello, World!", 0

global _startsection .text_start:    mov  rdi, `Hello, W`    mov  rax, `orld!\n\0\0`    push rax    push rdi    mov  rax,    1    mov  rdi,    1    mov  rsi,    rsp    mov  rdx,    14    syscall    pop  rdi    pop  rax    mov  rax,    60    mov  rdi,    0    syscall

FASM

Linux

;compile with:    fasm hello.asm hello;                 chmod 755 hello;run with:        ./helloformat ELF64 executable 3            ; Linux 64 bit executableentry _start                         ; label to start executionsegment executable readable          ; code segment_start:  .write:    mov    rax, 1                    ; sys_write    mov    rdi, 1                    ; stdout    mov    rsi, message              ; pointer to string to write    mov    rdx, endmessage - message ; length of string    syscall                          ; print the string  .exit:    mov    rax, 60                   ; sys_exit    xor    rdi, rdi                  ; exit code 0    syscall                          ; exit programsegment readable writable            ; 'data' segmentmessage: db "Hello, World!"          ; message to print         db 0x0a                     ; line feedendmessage:                          ; endmessage - message = length

Windows

format PE consoleentry startinclude 'win32ax.inc'section '.rdata' data readable  message       db 'Hello, World!', 13, 10  ; `=` is used to define the constant. `$` is the address of current position  message_len   = $ - messagesection '.code' code readable executable  ; `invoke <PROC>, <...ARGS>` is a macro, equivalent to pushing arguments on the stack and `call`ing the procedure   start:    ; Get a handle to standard output. Result is stored in EAX.    invoke GetStdHandle, \   ; https://learn.microsoft.com/en-us/windows/console/getstdhandle       STD_OUTPUT_HANDLE ; -11    ; Print the message to the console using the handle from EAX    invoke WriteConsoleA, \ ; https://learn.microsoft.com/en-us/windows/console/writeconsole       eax,  \ ; HANDLE  hConsoleOutput       message,   \; void    *lpBuffer       message_len,   \; DWORD   nNumberOfCharsToWrite       NULL,          \; LPDWORD lpNumberOfCharsWritten (optional)       NULL; void    *lpReserved  (must be null)    ; Exit the program    invoke ExitProcess, 0; Import Section (used to interface with dynamic libraries)section '.idata' import data readable  ; `library` is a macro that must be placed directly in the beginning of the import data.  ; It defines from what libraries the functions will be imported.  ; It should be followed by any amount of the pairs of parameters,   ; each pair being the label for the table of imports from the given library,   ; and the quoted string defining the name of the library.  library kernel32, 'kernel32.dll'  ; `import` macro generates the import table.   ; It needs first parameter to define the label for the table (the same as declared earlier to the library macro),  ; and then the pairs of parameters each containing the label for imported pointer and the quoted string  ; defining the name of function exactly as exported by library.  import kernel32,                       \         GetStdHandle,  'GetStdHandle',  \         WriteConsoleA, 'WriteConsoleA', \         ExitProcess,   'ExitProcess'

XBasic

PROGRAM "hello"VERSION "0.0003"DECLARE FUNCTION Entry()FUNCTION Entry()  PRINT "Hello World"END FUNCTIONEND 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.CONSOLEWriteLn "Hello world!"

XLISP

(DISPLAY "Hello world!")(NEWLINE)

XPL0

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

XPath

'Hello world
'

XSLT

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

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

Yabasic

print "Hello world!"

YAMLScript

!YS-v0say: "Hello, world!"=>: (say "Hello, world!")=>: say("Hello, world!")say:  =>: "Hello, world!"say: ("Hello, " + "world!")say: ."Hello," "world!"say "Hello,": "world!"say "Hello," "world!":

Output:

Yorick

write, "Hello world!"

Z80 Assembly

org$4000txt_output:equ$bb5apushhlldhl,worldprint:lda,(hl)cp0jrz,endcalltxt_outputinchljrprintend:pophlretworld:defm"Hello world!\r\n\0"

zkl

println("Hello world!");

Zig

const std = @import("std");pub fn main() !void {    const stdout = std.io.getStdOut();    try stdout.writeAll("Hello world!\n");}

Zoea

program: hello_world   output: "Hello  world!"

Zoea Visual

Zoomscript

print "Hello world!"

ZX Spectrum Basic

10 print "Hello world!"