Hello world/Text - Rosetta Code

Hello world/Text
You are encouraged to solve this task according to the task description, using any language you may know.

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

print(‘Hello world!’)

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

         WTO   'Hello world!'
         BR    14            Return
         END

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

echo Hello world!

; 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

        .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

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

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

  org 100h

  mov dx, msg
  mov ah, 9
  int 21h

  mov ax, 4c00h
  int 21h

msg:
  db "Hello world!$"

use16
format MZ
entry code:start

segment code
start:
;----Define the data segment----
    mov    ax, data0     ;load the address of data segment into ax
    mov    ds, ax        ;load address of the data segment into
                         ;data segment register
;-------------------------------
    lea    di, [msg]     ;load address of message into di
    call   pascalprint   ;call the routine that prints a pascal string

exit:
    mov    ax, 0x4c00    ;load 4c into ah, al is error code.
    int    0x21          ;exit to dos

pascalprint:             ;routine to print a pascal string.
    movzx  cx, byte[di]  ;load the first byte into cx. The length of string
    mov    dx, di        ;load into dx the address of string
    inc    dx            ;add one to dx, because the second byte is the
                         ;start of the string.
    mov    bx, 1         ;1 is file description of stdout
    mov    ax, 0x4000    ;service 40h writes a string to file
                         ;in this case the file is stdout.
    int    0x21          ;call the interrupt.
    ret                  ;return from routine.

segment data0
;A pascal string is a string where the first byte is the length
;of the string. That means that the string is limited to 255 bytes long.
;the length is calculated by the assembler.
msg:     db @f-$-1, "Hello world!"
 @@:

"Hello world!\n" . bye

.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

.global _start

.text
_start:
    mov x8, #64             //64 is write
    mov x0, #1              //1 is stdout
    adr x1, msg             //mov address of msg into x1
    mov x2, #(msgend - msg) //msgend minus msg is the length of message
    svc #0                  //system call
    mov x8, #93             //93 is exit
    mov x0, xzr             //0 is the exit code. xzr is the zero register
    svc #0                  //system call

msg:
    .ascii "Hello world!\n"
msgend:
.align 4

.global _start
.text
_start:
    adr  x0, msg       // load x0 with address of message
    bl   writez        // call the function that writes null-terminated string to stdout
    mov  x8, #93       // 93 is syscall exit
    mov  x0, xzr       // exit code = 0. Exit normal.
    svc  #0            // syscall
                       // If using as a function in C declare it as
writez:                // extern long writez(char *str);
    mov  x1, x0        // address of str needs to be in x1 for syscall
    sub  x0, x0, #1    // decrement x0, because the next statement increments it.
 0: ldrb w2, [x0, #1]! // increment x0, load byte value at x0 in w2
    cbnz w2, 0b        // if w2 is not zero jump back to 0: label
    sub  x2, x0, x1    // subtract x1 from x0, load into x2. length of str
    mov  x0, #1        // mov into x0 1. stdout
    mov  x8, #64       // mov into x8 64. write
    svc  #0            // syscall
    ret                // 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
.align 4

REPORT zgoodbyeworld.
  WRITE 'Hello world!'.

(cw "Hello world!~%")

(printc 'Hello! world!!)

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

trace("Hello world!");

with Ada.Text_IO; use Ada.Text_IO;
procedure Main is
begin
  Put_Line ("Hello world!");
end Main;

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

english()
displayln "Hello world!"

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

print( "Hello world!" )

o_text("Hello world!\n");

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

    return 0;
}

printf("Hello world!\n");

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

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

begin
    write( "Hello world!" )
end.

BEGIN
    WRITE( "Hello world!" );
END

Print('Hello world!')

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

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

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

system.println("Hello world!")

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

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

echo["Hello, World!"]

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

'Hello world!'

"Hello world!"

log "Hello world!"

 PRINT "Hello world!"

(puts "Hello world!")

(prn "Hello world!")

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

(print "Hello world!")

use std
print "Hello world!"

.global main

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

main:
    ldr r0, =message
    bl printf

    mov r7, #1
    swi 0

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

print "Hello world!"

Output:

.-$'Hello, World!'

print "Hello world!"

write('Hello world!');

10 PRINT "Hello World"

implement main0 () = print "Hello world!\n"

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

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

SendInput Hello world!{!}

ConsoleWrite("Hello world!" & @CRLF)

(print "Hello World!")

Print: "Hello World!";

BEGIN{print "Hello world!"}

END {
     print "Hello world!"
    }

//  { 
    print "Hello world!" 
    exit
    }

//  { 
    print "Hello world!" 
    }

//

Disp "Hello world!",i

main()
{
    putstr("Hello world!*n");
    return(0);
}

Log("Hello world!")

"Hello world!" <<

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

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

import ballerina/io; 

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

Output:

echo "Hello world!"

10 print "Hello world!"

PRINT "Hello world!"

PRINT "Hello world!"

echo Hello world!

setlocal enableDelayedExpansion
echo Hello world^^!

@echo off
setlocal enableextensions
call :char 72
call :char 101
call :char 108
call :char 108
call :char 111
call :space
call :char 119
call :char 111
call :char 114
call :char 108
call :char 100
call :char 33
exit /b 0

:space
:: https://stackoverflow.com/a/9865960
:: https://stackoverflow.com/a/31396993
for /f %%A in ('"prompt $H &echo on &for %%B in (1) do rem"') do <nul set /p=".%%A "
goto :eof

:char
cmd /c exit %1
<nul set /p=%=ExitCodeAscii%
goto :eof

const hello = "Hello world!\n"

print(hello)

      PRINT "Hello world!"

"Hello world!
"

GET "libhdr"

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

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

*`Hello, World!

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

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

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

use Console

define Main
    Console.Println "Hello world"
end

echo 'Hello world!'

print('Hello world!')

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

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

print "Hello world!"

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 ;

print("Hello world!")

display "Hello world!"

print "Hello world!"

10 print "Hello world!"

•Out "Hello world!"

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

put$"Hello world!"

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

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

p "Hello world!"

echo Hello world!

main ["Hello world!"]

"Hello world!"sh

#include<stdio.h>

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

#include<stdio.h>

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

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

int main(void)
{
  printf("Hello world!\n");
  return EXIT_SUCCESS;
}

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

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

namespace HelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            System.Console.WriteLine("Hello world!");
        }
    }
}

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

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

#include <iostream>

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

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

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

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

Hello_world/Text

Output:

module hello_world;
import stdio as io;

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

import std::io;

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

Locate 1,1,"Hello World!"

"Hello World!"

"Hello world!" writeln

print "Hello world!";;

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

writeln("Hello world!");

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.

10 print "Hello world!"

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

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

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

Start = "Hello world!"

'hello world!' -> print

? "Hello world!"

(printout t "Hello world!" crlf)

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

(println "Hello world!")

message(STATUS "Hello world!")

	program-id. hello.
	procedure division.
		display "Hello world!".
		stop run.

display"Hello, world".

class Hello
    def main
        print 'Hello world!'

console.log "Hello world!"

print "Hello world!"

<cfoutput>Hello world!</cfoutput>

PRINT "Hello world!"

'Hello world!'

"Hello world!"

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

Output:

(format t "Hello world!~%")

(print "Hello world!")

;; Project : Hello world/Text

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

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

print Hello world!

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

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

print "Hello world!"

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

puts "Hello world!"

." Hola, mundo!"

import std.stdio;

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

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

io.writeln( 'Hello world!' )

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

"Hello world!"

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

[Hello world!]p

5735816763073014741799356604682 P

$ write sys$output "Hello world!"

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

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

o:"Hello world!

          START     ;Hello World

          RECORD  HELLO
,         A11, 'Hello World'

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

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

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

PROGRAM HELLOWORLD;

BEGIN

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

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

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

showln "Hello world!"

echo "Hello world!"

print "Hello world!"!

"Hello world!" pl

# Turn off tabular output:
.mode list
.headers off

select 'Hello world!';

Output:

PrintLn('Hello world!');

print("Hello world!")

module: hello-world

format-out("%s\n", "Hello world!");

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

!print "Hello world!"

println("Hello world!")

stdout.println("Hello world!")

print "Hello world!"

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

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

OUTPUT('Hello world!');

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

a
Hello World!
.
p
Q

[ 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:

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

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

def main = "Hello World!"

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

program HelloWorld
    function main()
        SysLib.writeStdout("Hello world!");
    end
end

class
    HELLO_WORLD
create
    make
feature
    make
        do
            print ("Hello world!%N")
        end
end

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

putline ("Hello, world!");

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();

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

 "Hello world!"?

IO.puts "Hello world!"

main = text "Goodbye World!"

(message "Hello world!")

(princ "Hello world!\n")

writeLine("Hello world!")

🏁 🍇
  😀 🔤Hello world!🔤
🍉

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

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

[.>]@Hello world!

PRINT "HELLO WORLD!"

printfn "%s" "Hello world!"

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

"Hello world!" print

printl("Hello world!")

> "Hello world!"

"Hello world!
"

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

(print "Hello World")

(print "Hello World")

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

!!'Hello, World!';

say "Hello world!"

puts$ "Hello, world!\n"

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

TYPE "Hello, world" !

." Hello world!"

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

print *,"Hello world!"

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

write (89,100) "Hello world!"

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

? "Hello world!"
sleep

PROGRAM HelloWorld ;

{$APPTYPE CONSOLE}

(*) 

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

(*)

USES

    crt;

BEGIN

  WriteLn ( 'Hello world!' ) ;

END.

module HelloWorld where
main _ = println "Hello world!"

echo Hello world!

println["Hello world!"]

print "Hello, world!"
pause
end

displayNewMessage('Hello, world!')

print('Hello, world!')

println( 'Hello world!' )

."Hello, World!\n"

window 1
print @"Hello world!"

HandleEvents

PRINT "Hello world!"

Public Sub Main()

PRINT "Hello world!"
 
End

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

10 print "Hello world!"

'Hello, <> 'World! print

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

init
    print "Hello world!"

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

PRINT "Hello World"

STDOUT "Hello world!"

import gleam/io

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

"Hello world!"

'Hello world!'

 '"Goodbye,World!"'

 "'Goodbye,World!'"

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

debug="Hello world!"

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

package main

import "fmt"

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

"Hello world!"

print("Hello world!")

print("Hello world!")

println "Hello world!"

10 PRINT "Hello world!"

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

echo "Hello world!";

? "Hello world!"

use fmt;

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

main = putStrLn "Hello world!"

trace("Hello world!");

println "Hello world!"

WRITE() 'Hello world!'

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

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

end goodbyeWorld;

putStrLn("Hello world!")

"Hello world!\n";

~&  "Hello world!"  ~

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

Output:

PRINT("Hello world!");

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

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

H

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

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

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

(print "Hello world!")

software {
    print("Hello world!")
}

     START WATYHELLO
           H
     HELLO DAC 12,HELLO WORLD@
           DENDSTART

        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

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

print,'Hello world!'

module Main

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

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

import std::stdio::stdout

stdout.print('Hello, world!')

(print "Hello, world!")

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

   10 PRINT "Hello world!"
   20 END

"Hello world!" println

"Hello world!" println

PRINT "Hello world!"

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

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

   'Hello world!'
Hello world!

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

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

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

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

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

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

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

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

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

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

print 'Hello'
println 'World'

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

#import "Basic";

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

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

(print "Hello world!")

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

document.write("Hello world!");

print('Hello world!');

WScript.Echo("Hello world!");

console.log("Hello world!")

/*MESSAGE Hello world!

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

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

"Hello world!\n" putchars.

"Hello world!"

Print "Hello world!"

puts("Hello world!")

println("Hello world!")

"Hello world!"

`0: "Hello world!\n"

s: "Hello world!"
s

\echo "Hello world!"

return = "Hello world!";

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

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

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

 

V2; W0;
RESTART; J999; J999;
PROGRAM;                   (main program);
   V0 = Q0/AV1/AV2;
   V1 = B0750064554545700; ("Hello" in Flexowriter code);
   V2 = B0767065762544477; ("World" in Flexowriter code);
   V0; =Q9; POAQ9;         (write "Hello World" to Flexowriter);
999;  OUT;
   FINISH;

Hello world\!

"#!/usr/local/bin/kite

"Hello world!"|print;

"Hello world!" say

:- module main.

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

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

fun main()
  "Hello world!".println

println("Hello world!")

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

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

print 'Hello world!'

`plain
'Hello world!' #echo #

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

fn.println(Hello world!)

"Hello world!\n" .

writeln "Hello"

'Hello world!'

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

putln "Hello world!".

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

.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

procedure:
display "Hello World!" crlf

#eval "Hello world!"

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

#eval main

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

print "Hello world!"

#
# Hello world in lil
#

print "Hello, world!"

print("Hello world!")

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

\version "2.18.2"
global = {
  \time 4/4
  \key c \major
  \tempo 4=100
}
\relative c''{ g e e( g2)
}
\addlyrics {
  Hel -- lo,   World!
}

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

put "Hello world!"

trace("Hello world!")

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

puts("Hello world!");

puts(nonewline: "Hello world!");

puts(stderr, "Hello world!");

put "Hello World!"

Answer "Hello World!"

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

write "Hello world!" & return to stdout

; 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], [14 x i8]* @str, i32 0,i32 0))
  ret i32 0
}

print "Hello world!"

program hello;

begin
  writeln("Hello, World!")
end

block

begin
  writeln("Hello, World!")
end;

Output:

print [Hello world!]

type [Hello world!]

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

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

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

AFFICHER [U, /] 'Hello world!'

"Hello world!" ,t nl

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

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

module HelloWorld {
    print "Hello World!"
}
HelloWorld

`Hello world!'

        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

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

(format t "Hello world!~%")

(print "Hello world!")

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

all:
$(info Hello world!)

('&%: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:

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

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

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

output "Hello world!\n";

"Hello, World!"

Print["Hello world!"]

>> disp('Hello world!')

fmod BYE-WORLD is

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

red sayBye .

print("Hello world!");

print "Hello world!"

format "%" "Hello world!"

<PRINC "Hello world!">
<CRLF>

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

Say:Hello world!

helloWorld;

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

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

message "Hello world!"; end

TextWindow.WriteLine("Hello world!")

"Hello world!" puts

10 PRINT "Hello world!"
20 END

print "Hello world!"

output ["Hello World"];

Output:

   .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

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

echo -ag Hello world!

Hello world!

MODULE Hello;
IMPORT InOut;

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

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.

MODULE Goodbye EXPORTS Main;

IMPORT IO;

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

|Hello, World!| PRINT .

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

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

proc main =
    println "Hello, world"
end

println "Hello, world"

10 PRINT "Hello world!"

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

Write "Hello world!",!

$print Hello world

module: c
$print Hello world

module: python
$print Hello world

module: js
$print "Hello world"

module: go
$print Hello world

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

SELECT 'Hello world!';

print "Hello world!";

Hello world!

println "Hello world!"

void main() writeln "Hello world!";

$print("Hello world!");

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

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

say  'Hello world!'

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

Output:

(println "Hello world!")

printf("Hello world!\n")

echo("Hello world!")

stdout.writeLine("Hello World!")

print "Hello world!"

"Hello world!"

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

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

10 ? "HELLO WORLD!"

10 PRINT "HELLO WORLD!"

print "Hello world!"

module hello_world
imports native.io.output.say

say("Hello, world!")

end

(format t "Hello world!")

(print "Hello world!")

print "Hello World!"

exec format(t, "Hello World!")

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

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

import io

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

Output:

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

print_endline "Hello world!"

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

disp("Hello world!");

printf("Hello world!");

package main
import "core:fmt"

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

"Hello world!" .

(print "Hello world!")

`Hello world!\n' print flush

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

Output:

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

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

/* Rexx */
say 'Hello world!'

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

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

PROC main:
    PRINT "Hello, world!"
    GET
ENDP

(print "Hello world!")

Output:

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

Output:

print "Hello world!"

{Show "Hello world!"}

print("Hello world!")

program byeworld;
begin
 writeln('Hello world!');
end.

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

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

##
println('Hello World!');

Output:

print "Hello world!\n"
end

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

.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

;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

#include default-libraries

#author Childishbeat

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

print "Hello world!"

end

."Hello, World!\n"

print "Hello world!\n";

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

use 5.010;
say 'Hello world!';

chaap 'Hello world!';

Output:

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

'Hello World' printString

module helloworld;
extern printf;

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

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

Hello world!

println("Hello, world!")

(prinl "Hello world!")

print("hello, world!")

? 'hello, world!'

(prNL "Hello World!");

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

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

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

T:Hello world!

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

fputs("Hello world!\n")

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

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

set serveroutput on

BEGIN
  DBMS_OUTPUT.PUT_LINE('Hello world!');
END;
/

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

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

print "Hello world!"

output = println("Hello world!")

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

printf('Hello world!\n');

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

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

(Hello world!) ==

(Hello world!) =

(Hello world!) print

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

"Hello world!\n" print

#COMPILE EXE
#COMPILER PBCC 6

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

'Hello world!'

println("Hello world!");

printline Hello world!

print(Hello world!)

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

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

using system;

puts "Hello world!\n" ;

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

Debug("Hello world!")

print "Hello world!"

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

print("Hello world!")

import __hello__

import __phello__

import __phello__.spam

PRINT "Hello world!"

say "Hello world!"

"Hello world!" print

10 print "Hello world!"

 cat("Hello world!\n")

 message("Hello world!")

 print("Hello world!")

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

	on start

		print "Hello world!"

(printf "Hello world!\n")

say 'Hello world!';

"Hello, World!".say();

'Hello world!' print

program hello

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

end

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

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

print "Hello world!"

print "Hello world!"

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

' Hello world!

Js.log("Hello world!")

Output:

'Hello_world! s:put nl

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

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

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

call lineout ,"Hello world!"

print("Hello world!")

print("Hello world!");

See "Hello world!"

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

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

Shout "Hello world!"

Require Import Coq.Strings.String.

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

Output:

TITLE Goodbye World;

LET NL=10;

EXT PROC(REF ARRAY BYTE) TWRT;

ENT PROC RRJOB()INT;

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

ENDPROC;

puts "Hello world!"

$stdout.puts "Hello world!"

 STDOUT.write "Hello world!\n"

$>.puts "Hello world!"

$>.write "Hello world!\n"

print "Hello world!"

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

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

print "Hello world!"

"Hello world!"!

print("Hello world!\n");

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

[
    "DEBUG;THello, World!"
]

# Simple Hello World program in SVM2 format
10 DEBUG;Thello World

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

'Hello World!",nl

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

println("Hello world!")

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

println("Hello world!")

Console.withErr(Console.out) { Console.err.println("This goes to default _out_") }

  Console.err.println ("Err not deviated")
  Console.setErr(Console.out)
  Console.err.println ("Err deviated")
  Console.setErr(Console.err) // Reset to normal

"Hello world!"

(display "Hello world!")
(newline)

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

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

disp("Hello world!");

print "Hello world!"

print "Hello world!"
delayOnClick

i\
Hello world!
q

$ include "seed7_05.s7i";

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

'Hello world!' printLine.

put "Hello world!"

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

print("Hello world!");

out("Hello world!");end

(output "Hello world!~%")

say 'Hello world!'

„Hello world!”.say;

printLine Hello world!

dtxt
Hello world!

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

BEGIN
   OUTTEXT("Hello world!");
   OUTIMAGE
END

requires "sio";

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

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

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

print("Hello world!")

"Hello world!"

inform: 'Hello world!'.

(write "Hello, world!")

PRINT "Hello world!"

Transcript show: 'Hello world!'; cr.

'Hello world!' printNl.

PRINT "Hello world!"

PRINT "Hello world!"

    OUTPUT = "Hello world!"
END

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

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

class Main

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

end

extern print

dv Msg Goodbye,World!

mov eax Msg
push
call print
pop

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

print("Hello world!");

#.output("Hello world!")

select 'Hello world!' text from dual;

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

SET SERVEROUTPUT ON;

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

print "Hello world!\n"

display "Hello world!"

Print("Hello world!")

andika("Hello world!")

print("Hello world!")

println("Hello world!")

 'hello world' []

c,x,Hello World!,v,x

'Hello World' -> !OUT::write

'Hello World' !

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

puts stdout {Hello world!}

puts $fileID {Hello world!}

^AHello world!^A$$

println("Hello world!");

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

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

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

Output:

%TestML 0.1.0
Print("Hello world!")

Disp "Hello world!

Disp "Hello world!"

10 PRINT "Hello, World!"
20 END

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

echo("Hello world!");

Hello world!

PRINT "Hello world!"

(textout "Hello, World!")

PRINT " Hello world! "

"Hello world!" print

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

$$ MODE TUSCRIPT
PRINT "Hello world!"

Print "Hello world!"

message "Hello world!"

main = '(printLine "Hello world!")

#!/bin/sh
echo "Hello world!"

#!/bin/csh -f
echo "Hello world!\!"

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

out "hello world!" endl console

#show+

main = -[Hello world!]-

#import std

#executable ('parameterized','')

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

print("hello woods!")

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

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

|10 @Console &vector $2 &read $1 &pad $5 &write $1 &error $1

|100

@on-reset ( -> )
	;my-string print-text
	BRK

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

@my-string
	"Hello 20 "World! 0a00

Output:

"Hello world!" puts

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

import stdlib.*;

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

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

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

WScript.Echo "Hello world!"

Message("Hello world!")

@SAY "Hello world!";

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

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;

echo "Hello world!\n"

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

Imports System

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

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

println('Hello World!')

10 ?="Hello world!"

T:Hello world!
S:

prn "Hello world!"

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

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

print 1 "Hello world!"
end

1 print("Hello world!");

import whiley.lang.System

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

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

Print["Hello world!"]

System.print("Hello world!")

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

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

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

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

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

; compile with:
; nasm -f elf64 hello0.asm -o hello0.o
; ld hello0.o -o hello0 -z noexecstack -no-pie -s

global _start

section .text
_start:
 .write:
    mov    rax,    1
    mov    rdi,    1
    mov    rsi,    message
    mov    rdx,    14
    syscall
 .exit:
    mov    rax,    60
    xor    rdi,    rdi
    syscall

section .data
message: 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 hello1

global main
extern puts

section .text
main:
    mov    rdi,    message
    sub    rsp,    8
    call   puts
    add    rsp,    8
    xor    rax,    rax
    ret

section .data
message: db "Hello, World!", 0

global _start

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

;compile with:    fasm hello.asm hello
;                 chmod 755 hello
;run with:        ./hello

format ELF64 executable 3            ; Linux 64 bit executable
entry _start                         ; label to start execution

segment 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 program
segment readable writable            ; 'data' segment
message: db "Hello, World!"          ; message to print
         db 0x0a                     ; line feed
endmessage:                          ; endmessage - message = length

format PE console
entry start
include '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   = $ - message

section '.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'

PROGRAM "hello"
VERSION "0.0003"

DECLARE FUNCTION Entry()

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

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

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

(DISPLAY "Hello world!")
(NEWLINE)

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

'Hello world
'

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

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

print "Hello world!"

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

Output:

write, "Hello world!"

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"

println("Hello world!");

const std = @import("std");

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

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

program: hello_world 
  output: "Hello  world!"

print "Hello world!"

10 print "Hello world!"