Hello world/Text: Difference between revisions

 

=={{header|0815}}==

<:48:x<:65:=<:6C:$=$=$$~<:03:+

$~<:ffffffffffffffb1:+$<:77:~$

<:06:x-$x<:0e:x-$=x<:43:x-$

 

 

=={{header|11l}}==

 

=={{header|360 Assembly}}==

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

HELLO CSECT

USING HELLO,15

DC XL2'00' 2 bytes binary of zeros

DC C'Hello world!' Text to be written to system console

Using WTO Macro to generate SVC 35 and message area:

BR 14 Return

END

 

=={{header|4DOS Batch}}==

 

=={{header|6502 Assembly}}==

; String printing limited to strings of 256 characters or less.

 

 

text:

 

=={{header|6800 Assembly}}==

.tf gbye6800.obj,AP1

.lf gbye6800

;=====================================================;

string .as "Hello world!",#13,#10,#0

 

=={{header|8080 Assembly}}==

 

; As you can see, it is similar to the 8086, and CP/M is very

; similar to DOS in the way it is called.

; JMP saves a byte (if you've only got 64k of address space you want to

; save bytes).

 

=={{header|8086 Assembly}}==

 

.MODEL TINY

.DATA

MOV AX, 4C00h ; go back to DOS

INT 21h

 

With A86 or NASM syntax:

 

=={{header|8th}}==

 

=={{header|AArch64 Assembly}}==

.equ SVC_WRITE, 64

.equ SVC_EXIT, 93

 

msg: .ascii "Hello World!\n"

 

=={{header|ABAP}}==

 

=={{header|ACL2}}==

 

=={{header|ActionScript}}==

 

=={{header|Ada}}==

{{works with|GCC|4.1.2}}

procedure Main is

begin

Put_Line ("Hello world!");

 

=={{header|Agena}}==

 

=={{header|Aime}}==

 

or:

 

main(void)

{

 

return 0;

 

=={{header|Algae}}==

 

=={{header|ALGOL 60}}==

OUTSTRING(1,'('Hello world!')');

SYSACT(1,14,1)

 

=={{header|ALGOL 68}}==

printf($"Hello world!"l$)

 

=={{header|ALGOL W}}==

write( "Hello world!" )

 

=={{header|ALGOL-M}}==

WRITE( "Hello world!" );

 

=={{header|Alore}}==

 

=={{header|AmbientTalk}}==

 

=={{header|AmigaE}}==

WriteF('Hello world!\n')

 

=={{header|AntLang}}==

Note, that "Hello, World!" prints twice in interactive mode.

One time as side-effect and one as the return value of echo.

 

=={{header|Anyways}}==

 

"Ow!" it said.

 

=={{header|APL}}==

 

=={{header|AppleScript}}==

To show in Script Editor Result pane:

 

To show in Script Editor Event Log pane:

 

=={{header|Applesoft BASIC}}==

Important Note: Although Applesoft BASIC allowed the storage and output of mixed-case strings, the ability to enter mixed-case via the keyboard and to output mixed-case on the default display was not offered as standard equipment on the original Apple II/II+. Since Applesoft WAS the default programming language for the Apple II+, perhaps some flexibility in the task specification could be offered, for this and for other systems that lacked proper mixed-case I/O capabilities in at least one popular configuration.

 

 

=={{header|Apricot}}==

 

=={{header|Arc}}==

 

=={{header|Arendelle}}==

 

=={{header|Argile}}==

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

 

=={{header|ARM Assembly}}==

 

 

message:

 

mov r7, #1

 

=={{header|ArnoldC}}==

TALK TO THE HAND "Hello world!"

 

=={{header|Arturo}}==

 

{{out}}

=={{header|AsciiDots}}==

 

.-$'Hello, World!'

 

=={{header|Astro}}==

 

=={{header|Asymptote}}==

 

 

=={{header|ATS}}==

 

=={{header|AutoHotkey}}==

script launched from windows explorer

FileAppend, Goodbye`, World!, CONOUT$

scripts run from shell

[requires Windows XP or higher; older Versions of Windows don´t have the "AttachConsole" function]

 

=={{header|AutoIt}}==

 

=={{header|AutoLISP}}==

 

=={{header|Avail}}==

 

=={{header|AWK}}==

 

 

"BEGIN" is a "special pattern" - code within "{}" is executed before the input file is read, even if there is no input. "END" is a similar pattern, for after completion of main processing.

END {

print "Hello world!"

}

 

For a file containing data, the work can be done in the "body". The "//" is "match anything" so gets the first data, the "exit" halts processing the file (any "END" would then be executed). Or instead of //, simply 1 is true.

// {

print "Hello world!"

exit

}

 

 

For a "single record" file.

// {

print "Hello world!"

}

 

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

//

 

=={{header|Axe}}==

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

 

=={{header|B}}==

{{works with|The Amsterdam Compiler Kit - B|V6.1pre1}}

{

putstr("Hello world!*n");

return(0);

 

=={{header|B4X}}==

 

=={{header|Babel}}==

 

 

=={{header|bash}}==

 

=={{header|BASIC}}==

{{works with|BASICA}}

{{works with|Commodore BASIC}}

{{works with|Locomotive Basic}}

{{works with|M2000 Interpreter}}

{{works with|MSX BASIC}}

{{works with|Tiny BASIC}}

 

{{works with|7Basic}}

{{works with|BaCon}} [[Category:BaCon]]

{{works with|M2000 Interpreter}}

 

=={{header|BASIC256}}==

 

=={{header|Batch File}}==

'''Under normal circumstances, when delayed expansion is disabled'''

 

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

 

=={{header|Battlestar}}==

<!--- supports C syntax highlighting --->

 

 

=={{header|BBC BASIC}}==

 

=={{header|bc}}==

 

=={{header|BCPL}}==

 

LET start() = VALOF

{ writef("Hello world!")

RESULTIS 0

 

=={{header|beeswax}}==

Straightforward:

 

 

Less obvious way:

 

`

r

W

`

 

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

 

l o

``

``

e H

 

=={{header|Befunge}}==

 

=={{header|Bird}}==

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

 

define Main

Console.Println "Hello world"

 

=={{header|Blast}}==

.begin

display "Hello world!"

return

 

=={{header|blz}}==

 

=={{header|BML}}==

 

=={{header|Boo}}==

 

=={{header|bootBASIC}}==

 

=={{header|Brace}}==

use b

Main:

 

=={{header|Bracmat}}==

 

=={{header|Brainf***}}==

 

Commented version:

 

[

 

CRLF

 

Uncommented:

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

>+..<.<++++++++.>>>+.<<+.<<<<++++.<++.>>>+++++++.>>>.+++.

It can most likely be optimized, but this is a nice way to show

how character printing works in Brainf*** :)

 

=={{header|Brat}}==

 

=={{header|Brlcad}}==

The mged utility can output text to the terminal:

 

echo Hello world!

 

=={{header|Burlesque}}==

 

"Hello world!"sh

 

Although please note that ''sh'' actually does not print anything.

=={{header|C}}==

{{works with|gcc|4.0.1}}

#include <stdio.h>

 

printf("Hello world!\n");

return EXIT_SUCCESS;

Or:

#include <stdio.h>

 

puts("Hello world!");

return EXIT_SUCCESS;

Or, the eternal favourite :)

#include<stdio.h>

 

printf("\nHello world!");

return 0;

 

or better yet...

#include<stdio.h>

 

return printf("\nHello World!");

}

 

=={{header|C sharp|C#}}==

{{works with|Mono|1.2}}

{{works with|Visual C sharp|Visual C#|2003}}

{

class Program

}

}

 

=={{header|C++}}==

 

 

=={{header|C++/CLI}}==

int main()

{

Console::WriteLine("Hello world!");

 

=={{header|C1R}}==

{{out}}

<pre>

 

=={{header|C2}}==

import stdio as io;

 

io.printf("Hello World!\n");

return 0;

 

=={{header|Casio BASIC}}==

or just

 

=={{header|Cat}}==

 

=={{header|Cduce}}==

 

=={{header|Chapel}}==

 

=={{header|Chef}}==

Ingredients.

Pour contents of the mixing bowl into the baking dish.

 

=={{header|ChucK}}==

 

=={{header|Cind}}==

 

execute() {

host.println("Hello world!");

}

 

=={{header|Clay}}==

println("Hello world!");

 

=={{header|Clean}}==

 

=={{header|Clio}}==

 

=={{header|Clipper}}==

 

=={{header|CLIPS}}==

 

=={{header|Clojure}}==

 

=={{header|CMake}}==

 

This outputs

{{works with|Dell Enterprise COBOL}}

 

procedure division.

display "Hello world!".

 

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

{{works with|GnuCOBOL}}

 

 

<pre>prompt$ cobc -x -frelax-syntax -free hello.cob

 

=={{header|Cobra}}==

def main

 

=={{header|CoffeeScript}}==

{{works with|Node.js}}

{{works with|Rhino engine}}

 

=={{header|ColdFusion}}==

 

=={{header|Comal}}==

 

=={{header|Comefrom0x10}}==

 

 

=={{header|Commodore BASIC}}==

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

20 print "Hello world!"

30 end

 

{{Out}}<pre>Hello world!</pre>

 

=={{header|Common Lisp}}==

 

Or

 

 

===Alternate solution===

I use [https://franz.com/downloads/clp/survey Allegro CL 10.1]

 

;; Project : Hello world/Text

 

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

Output:

<pre>

 

=={{header|Component Pascal}}==

MODULE Hello;

IMPORT Out;

Out.String("Hello world!"); Out.Ln

END Do;

Run command ''Hello.Do'' by commander.

 

=={{header|Corescript}}==

 

=={{header|Cowgol}}==

print("Hello world!");

 

 

=={{header|Crack}}==

import crack.io cout;

cout `Hello world!\n`;

 

=={{header|Creative Basic}}==

OPENCONSOLE

 

 

END

 

=={{header|Crystal}}==

 

=={{header|D}}==

{{works with|D|2.0}}

 

void main() {

writeln("Hello world!");

 

=={{header|Dafny}}==

method Main() {

print "hello, world!\n";

assert 10 < 2;

}

 

=={{header|Dao}}==

 

=={{header|Dart}}==

var bye = 'Hello world!';

print("$bye");

 

=={{header|DataWeave}}==

 

=={{header|DBL}}==

; Hello world for DBL version 4 by Dario B.

;

PROC

;------------------------------------------------------------------

 

OPEN (1,O,'TT:')

 

CLOSE 1

 

=={{header|Dc}}==

...or print a numerically represented string.

 

=={{header|DCL}}==

 

=={{header|DDNC}}==

The code can be divided into three sections. The first stores the character numbers in order in an array. The second sets up the loop by loading a delay of 500 milliseconds to slot 3, the start address of the character array in memory to slot 2, and the number of times to loop (14) plus one to slot 5. The third section starts the loop of displaying the characters, waiting for the delay time, incrementing the pointer, decrementing the counter, and checking if the counter is negative to know whether to continue the loop.

 

0 111 10

0 15 11

61 4

64

 

=={{header|Delphi}}==

program ProjectGoodbye;

{$APPTYPE CONSOLE}

WriteLn('Hello world!');

end.

 

=={{header|DeviousYarn}}==

 

=={{header|DIBOL-11}}==

START ;Hello World

 

END

 

 

=={{header|DIV Games Studio}}==

PROGRAM HELLOWORLD;

 

END

 

 

=={{header|DM}}==

/client/New()

..()

src << "Hello world!"

 

=={{header|Dragon}}==

showln "Hello world!"

 

=={{header|DWScript}}==

PrintLn('Hello world!');

 

=={{header|Dyalect}}==

 

=={{header|Dylan}}==

module: hello-world

 

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

 

=={{header|Dylan.NET}}==

{{works with|.NET|4.5}}

One Line version:

 

Hello World Program:

//compile using the new dylan.NET v, 11.5.1.2 or later

//use mono to run the compiler

 

end class

 

=={{header|Déjà Vu}}==

 

=={{header|E}}==

 

 

=={{header|EasyLang}}==

 

 

=={{header|eC}}==

{

void Main()

PrintLn("Hello world!");

}

 

=={{header|EchoLisp}}==

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

 

=={{header|ECL}}==

OUTPUT('Hello world!');

 

=={{header|EDSAC order code}}==

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

[ A program for the EDSAC ]

[ Works with Initial Orders 2 ]

DF

EZPF [ Start program beginning at

{{out}}

<pre>HELLO WORLD</pre>

short version (without a function)

 

 

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

 

run = fn () {

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

 

=={{header|Egel}}==

def main = "Hello World!"

 

=={{header|Egison}}==

 

(define $main

(lambda [$argv]

(write-string "Hello world!\n")))

 

=={{header|EGL}}==

{{works with|EDT}}

{{works with|RBD}}

program HelloWorld

function main()

end

end

 

=={{header|Eiffel}}==

{{wikipedia|Eiffel (programming language)}}

HELLO_WORLD

create

print ("Hello world!%N")

end

 

=={{header|Ela}}==

 

=={{header|elastiC}}==

From the [http://www.elasticworld.org/man/elastic.html elastiC Manual].

 

 

// Import the `basic' package

 

// Invoke the `hello' function

 

=={{header|Elena}}==

{

 

=={{header|Elisa}}==

 

=={{header|Elixir}}==

IO.puts "Hello world!"

 

=={{header|Elm}}==

 

=={{header|Emacs Lisp}}==

 

=={{header|Emojicode}}==

😀 🔤Hello world!🔤

 

=={{header|Erlang}}==

 

=={{header|ERRE}}==

! Hello World in ERRE language

PROGRAM HELLO

PRINT("Hello world!")

END PROGRAM

 

=={{header|Euler Math Toolbox}}==

=={{header|Extended BrainF***}}==

 

 

=={{header|Ezhil}}==

 

=={{header|F_Sharp|F#}}==

or using .Net classes directly

 

=={{header|Factor}}==

 

=={{header|Falcon}}==

With the printl() function:

Or via "fast print":

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

 

class HelloText

{

}

}

 

=={{header|Fennel}}==

 

=={{header|ferite}}==

word.}}

 

=={{header|Fermat}}==

 

=={{header|Fexl}}==

 

=={{header|Fhidwfe}}==

 

=={{header|Fish}}==

Standard Hello, world example, modified for this task:

Explanation of the code:<br/>

<tt>!v"</tt> jumps over the <tt>v</tt> character with the <tt>!</tt> sign, then starts the string mode with <tt>"</tt> .<br/>

 

=={{header|FOCAL}}==

 

=={{header|Forth}}==

 

Or as a whole program:

 

 

=={{header|Fortran}}==

Simplest case - display using default formatting:

 

 

Use explicit output format:

 

 

Output to channels other than stdout goes like this:

 

 

uses the format given at label 100 to output to unit 89. If output unit with this number exists yet (no "<tt>OPEN</tt>" statement or processor-specific external unit setting), a new file will be created and the output sent there. On most UNIX/Linux systems that file will be named "<tt>fort.89</tt>".

 

=={{header|Fortress}}==

 

=={{header|FreeBASIC}}==

 

=={{header|Frege}}==

{{Works with|Frege|3.20.113}}

 

 

=={{header|friendly interactive shell}}==

Unlike other [[UNIX shell]] languages, fish doesn't support history substitution, so <code>!</code> is safe to use without quoting.

 

=={{header|Frink}}==

println["Hello world!"]

 

=={{header|FunL}}==

 

 

=={{header|Furor}}==

 

=={{header|FUZE BASIC}}==

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=d3a51f670e4eb0f793b513b14329be51 Click this link to run this code]'''

 

PRINT "Hello world!"

 

=={{header|GAP}}==

"Hello world!";

 

f := OutputTextUser();

WriteLine(f, "Hello world!\n");

 

=={{header|GB BASIC}}==

 

=={{header|gecho}}==

 

=={{header|Gema}}==

This code will write "Hello world!' no matter what input is given.

 

 

=={{header|Genie}}==

init

print "Hello world!"

 

=={{header|Gentee}}==

{

print("Hello world!")

 

=={{header|GFA Basic}}==

 

=={{header|GLBasic}}==

 

=={{header|Glee}}==

 

or

 

 

or to display with double quotes

 

 

or to display with single quotes

 

 

=={{header|Global Script}}==

 

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

 

=={{header|GlovePIE}}==

 

=={{header|GML}}==

 

=={{header|Go}}==

 

 

import "fmt"

 

 

=={{header|Golfscript}}==

 

=={{header|Gosu}}==

 

=={{header|Groovy}}==

 

=={{header|GW-BASIC}}==

 

=={{header|Hack}}==

 

=={{header|Halon}}==

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

 

 

=={{header|Harbour}}==

 

=={{header|Haskell}}==

main = putStrLn "Hello world!"

 

=={{header|Haxe}}==

 

=={{header|hexiscript}}==

 

=={{header|HicEst}}==

 

=={{header|HLA}}==

#include("stdlib.hhf")

begin goodbyeWorld;

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

 

 

=={{header|HolyC}}==

 

=={{header|Hoon}}==

 

=={{header|HPPPL}}==

 

=={{header|HQ9+}}==

{{incorrect|HQ9+|output isn't consistent with the task's requirements (and is probably incapable of solving the task).}}

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

- H : Print 'Hello World!'<br>

 

=={{header|Huginn}}==

exec huginn --no-argv -E "${0}" "${@}"

#! huginn

print( "Hello World!\n" );

return ( 0 );

=={{header|HTML5}}==

<!DOCTYPE html>

<html>

</body>

</html>

 

=={{header|Hy}}==

 

=={{header|i}}==

print("Hello world!")

 

=={{header|Icon}} and {{header|Unicon}}==

write( "Hello world!" )

 

=={{header|IDL}}==

 

=={{header|Inform 6}}==

print "Hello world!^";

 

=={{header|Inko}}==

 

 

=={{header|Integer BASIC}}==

NOTE: Integer BASIC was written (and hand-assembled by Woz himself) for the Apple 1 and original Apple 2. The Apple 1 has NO support for lower-case letters, and it was an expensive (and later) option on the Apple 2. This example accurately represents the only reasonable solution for those target devices, and therefore cannot be "fixed", only deleted.

 

 

=={{header|Io}}==

 

=={{header|Ioke}}==

 

=={{header|IS-BASIC}}==

 

=={{header|Isabelle}}==

imports Main

begin

value ‹''Hello world!''›

 

=={{header|IWBASIC}}==

OPENCONSOLE

 

 

END

 

=={{header|J}}==

 

Here are some redundant alternatives:

Hello world!

data

Hello world!

Hello world!

 

=={{header|Jack}}==

function void main () {

do Output.printString("Hello world!");

return;

}

 

=={{header|Jacquard Loom}}==

This weaves the string "Hello world!"

| |

| * * |

| |

| |

 

=={{header|Java}}==

{

public static void main(String[] args)

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

}

 

=={{header|JavaScript}}==

 

{{works with|NJS|0.2.5}}

{{works with|Rhino}}

{{works with|SpiderMonkey}}

 

{{works with|JScript}}

 

{{works with|Node.js}}

 

=={{header|JCL}}==

 

=={{header|Joy}}==

 

=={{header|jq}}==

 

=={{header|Jsish}}==

 

=={{header|Julia}}==

 

=={{header|K}}==

"Hello world!"

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

`0: "Hello world!\n"

s: "Hello world!"

s

\echo "Hello world!"

 

=={{header|Kabap}}==

 

=={{header|Kaya}}==

Void main() {

// My first program!

putStrLn("Hello world!");

 

=={{header|Kdf9 Usercode}}==

{{incorrect|Kdf9|output isn't consistent with the task's requirements: wording, punctuation.}}

 

V2; W0;

999; OUT;

FINISH;

 

=={{header|Keg}}==

 

=={{header|Kite}}==

simply a single line

 

 

=={{header|Kitten}}==

 

 

=={{header|Koka}}==

println("Hello world!")

 

=={{header|KonsolScript}}==

Displays it in a text file or console/terminal.

Konsol:Log("Hello world!")

 

=={{header|Kotlin}}==

println("Hello world!")

 

=={{header|KQL}}==

 

 

=={{header|Lambdatalk}}==

Hello world!

{h1 Hello world!}

_h1 Hello world!\n

 

=={{header|Lang5}}==

 

=={{header|langur}}==

 

=={{header|Lasso}}==

A plain string is output automatically.

 

=={{header|LaTeX}}==

\begin{document}

Hello World!

 

=={{header|Latitude}}==

 

=={{header|LC3 Assembly}}==

 

LEA R0, hello ; R0 = &hello

TRAP x22 ; PUTS (print char array at addr in R0)

HALT

hello .stringz "Hello World!"

Or (without PUTS)

LEA R1, hello ; R1 = &hello

TOP LDR R0, R1, #0 ; R0 = R1[0]

END HALT

hello .stringz "Hello World!"

 

=={{header|LDPL}}==

procedure:

display "Hello World!" crlf

 

=={{header|LFE}}==

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

 

=={{header|Liberty BASIC}}==

 

=={{header|LIL}}==

# Hello world in lil

#

 

 

=={{header|Lily}}==

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

 

 

Second, by using stdout directly:

 

 

=={{header|Lilypond}}==

global = {

\time 4/4

\addlyrics {

Hel -- lo, World!

 

=={{header|Limbo}}==

include "sys.m";

sys = load Sys Sys->PATH;

sys->print("Hello world!\n");

 

=={{header|Lingo}}==

 

or:

 

 

=={{header|Lisaac}}==

You can print to standard output in Lisaac by calling STRING.print or INTEGER.print:

 

+ name := GOODBYE; // Define the name of this object.

 

Section Public

 

However, it may be more straightforward to use IO.print_string instead:

 

+ name := GOODBYE2; // Define the name of this object.

 

Section Public

 

=={{header|Little}}==

Output to terminal:

 

Without the newline terminator:

 

 

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

 

=={{header|LiveCode}}==

 

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

 

Present a dialog box to the user

 

Example using command-line livecode-server in shell script

set the outputLineEndings to "lf"

 

Livecode also supports stdout as a device to write to

 

=={{header|LLVM}}==

 

; const char str[14] = "Hello World!\00"

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

call i32 @puts( i8* getelementptr ([14 x i8]* @str, i32 0,i32 0))

ret i32 0

 

=={{header|Lobster}}==

 

=={{header|Logo}}==

Print includes a line feed:

Type does not:

 

=={{header|Logtalk}}==

 

% the initialization/1 directive argument is automatically executed

:- initialization(write('Hello world!\n')).

 

 

=={{header|LOLCODE}}==

HAI

CAN HAS STDIO?

VISIBLE "Hello world!"

KTHXBYE

 

=={{header|LotusScript}}==

'This will send the output to the status bar at the bottom of the Notes client screen

print "Hello world!"

 

 

=={{header|LSE}}==

 

=={{header|LSE64}}==

 

=={{header|Lua}}==

Function calls with either a string literal or a table constructor passed as their only argument do not require parentheses.

 

Harder way with a table:

local chars = {"G","o","o","d","b","y","e",","," ","W","o","r","l","d","!"}

for i = 1, #chars do

end

 

=={{header|Luna}}==

hello = "Hello, World!"

 

=={{header|M2000 Interpreter}}==

Print "Hello World!" \\ printing on columns, in various ways defined by last $() for specific layer

Print $(4),"Hello World!" \\ proportional printing using columns, expanded to a number of columns as the length of string indicates.

Report "Hello World!" \\ proportional printing with word wrap, for text, can apply justification and rendering a range of text lines

 

=={{header|M4}}==

For the particular nature of m4, this is simply:

 

=={{header|Maclisp}}==

Or

 

=={{header|MAD}}==

 

PRINT FORMAT HELLO

 

=={{header|make}}==

Makefile contents:

all:

$(info Hello world!)

Running make produces:

 

 

=={{header|Malbolge}}==

'''Long version:'''

 

'''Short version:'''

 

{{Out}}

=={{header|MANOOL}}==

In &ldquo;applicative&rdquo; notation:

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

LISPish notation (ditto):

Using a colon punctuator (ditto):

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

 

=={{header|Maple}}==

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

Hello world!

 

=={{header|Mathcad}}==

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

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

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|MATLAB}}==

 

 

=={{header|Maude}}==

fmod BYE-WORLD is

 

 

red sayBye .

 

=={{header|Maxima}}==

 

=={{header|MAXScript}}==

or:

 

=={{header|MDL}}==

 

=={{header|MelonBasic}}==

 

=={{header|Mercury}}==

:- interface.

:- import_module io.

:- implementation.

main(!IO) :-

 

=={{header|Metafont}}==

 

=={{header|min}}==

 

=={{header|MiniScript}}==

 

=={{header|MiniZinc}}==

output ["Hello World"];

{{out}}

 

=={{header|MIPS Assembly}}==

{{works with|MARS}} and {{works with|SPIM}}

hello: .asciiz "Hello world!" #asciiz automatically adds the null terminator. If it's .ascii it doesn't have it.

 

 

li $v0, 10 # set the syscall to exit

 

=={{header|mIRC Scripting Language}}==

 

=={{header|ML/I}}==

 

=={{header|Modula-2}}==

IMPORT InOut;

 

InOut.WriteString('Hello world!');

InOut.WriteLn

 

=={{header|Modula-3}}==

 

IMPORT IO;

BEGIN

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

 

=={{header|MontiLang}}==

 

=={{header|Morfa}}==

import morfa.io.print;

func main(): void

println("Hello world!");

}

 

=={{header|Mosaic}}==

 

=={{header|MUF}}==

me @ "Hello world!" notify

exit

 

=={{header|MUMPS}}==

 

=={{header|MyDef}}==

Run with: <pre>mydef_run hello.def</pre>

Perl:

 

C:

module: c

$print Hello world

 

python:

module: python

$print Hello world

 

JavaScript

module: js

$print "Hello world"

 

go:

module: go

$print Hello world

 

=={{header|MyrtleScript}}==

func main returns: int {

print("Hello World!")

}

}

 

=={{header|MySQL}}==

 

 

=={{header|Mythryl}}==

 

 

=={{header|N/t/roff}}==

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

 

 

=={{header|Nanoquery}}==

 

=={{header|Neat}}==

 

 

=={{header|Neko}}==

 

=={{header|Nemerle}}==

class Hello

{

}

}

Easier method:

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

 

=={{header|NetRexx}}==

 

=={{header|Never}}==

prints("Hello world!\n");

0

 

{{out}}

=={{header|newLISP}}==

{{works with|newLisp|6.1 and after}}

 

=={{header|Nickle}}==

 

=={{header|Nim}}==

 

=={{header|Nit}}==

 

=={{header|NS-HUBASIC}}==

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

Using <code>?</code>:

 

Using <code>PRINT</code>:

 

=={{header|Nyquist}}==

[[Category:Nyquist Version 3.15]]

===LISP syntax===

 

Or

 

 

===SAL syntax===

 

Or

 

 

=={{header|Oberon-2}}==

MODULE Goodbye;

IMPORT Out;

World;

END Goodbye.

 

=={{header|Objeck}}==

class Hello {

function : Main(args : String[]) ~ Nil {

"Hello world!"->PrintLine();

}

 

=={{header|Objective-C}}==

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

 

#import <Foundation/Foundation.h>

 

}

}

 

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

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

 

#import <Foundation/Foundation.h>

 

}

}

 

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

 

#import <Foundation/Foundation.h>

 

}

}

 

=={{header|OCaml}}==

 

=={{header|Occam}}==

{{works with|kroc}}

PROC main (CHAN BYTE screen!)

out.string("Hello world!*c*n", 0, screen)

 

=={{header|Octave}}==

 

Or, using C-style function printf:

 

 

=={{header|Oforth}}==

 

=={{header|Ol}}==

 

=={{header|Onyx}}==

 

=={{header|OOC}}==

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

"Hello world!" println()

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

println("Hello world!")

 

=={{header|ooRexx}}==

Refer also to the [[#REXX|Rexx]] and [[#NetRexx|NetRexx]] solutions. Simple output is common to most Rexx dialects.

say 'Hello world!'

 

=={{header|OpenLisp}}==

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

#!/openlisp/uxlisp -shell

(format t "Hello world!~%")

(print "Hello world!")

 

Output:

 

=={{header|Openscad}}==

echo("Hello world!"); // writes to the console

text("Hello world!"); // creates 2D text in the object space

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

 

=={{header|Oxygene}}==

From [[wp:Oxygene (programming language)]]

namespace HelloWorld;

class method HelloClass.Main;

begin

end;

end.

<pre>

Hello world!

</pre>

 

=={{header|Oz}}==

 

=={{header|PARI/GP}}==

 

 

=={{header|Pascal}}==

{{works with|Free Pascal}}

begin

writeln('Hello world!');

 

=={{header|PASM}}==

 

=={{header|PDP-1 Assembly}}==

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

hello

/ above: title line - was punched in human readable letters on paper tape

end, . / sentinel for end of message

start 100 / tells assembler where program starts

 

=={{header|PDP-11 Assembly}}==

{{works with|UNIX|1}} to {{works with|UNIX|7}}

 

.text

start:

.data

outtext: <Hello world!\n>

 

=={{header|PepsiScript}}==

 

For typing:

 

#author Childishbeat

print "Hello world!"

 

For importing:

 

=={{header|Perl}}==

{{works with|Perl|5.8.8}}

 

{{works with|Perl|5.10.x}}

Backported from Raku:

 

or:

 

=={{header|Pharo}}==

"Sending message printString to 'Hello World' string"

 

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Hello world!"</span><span style="color: #0000FF;">)</span>

 

=={{header|PHL}}==

extern printf;

 

printf("Hello world!");

return 0;

 

=={{header|PHP}}==

echo "Hello world!\n";

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

 

=={{header|PicoLisp}}==

 

=={{header|Pict}}==

Using the syntax sugared version:

Using the channel syntax:

run ( prNL!["Hello World!" (rchan done)]

 

=={{header|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 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

 

=={{header|Pike}}==

write("Hello world!\n");

 

=={{header|PILOT}}==

 

=={{header|PIR}}==

print "Hello world!\n"

 

=={{header|Pixilang}}==

 

=={{header|PL/I}}==

put list('Hello world!');

 

=={{header|PL/M}}==

 

=={{header|PL/SQL}}==

{{works with|Oracle}}

set serveroutput on

 

END;

/

 

<pre>

 

=={{header|Plain English}}==

\...and backslashes are comments!

To run:

Write "Hello World!" to the console.

Wait for the escape key.

 

=={{header|Plan}}==

This prints HELLO WORLD on operator's console.

 

#PROGRAM HLWD

#LOWER

#END

#FINISH

 

=={{header|Pony}}==

new create(env: Env) =>

 

=={{header|Pop11}}==

 

=={{header|PostScript}}==

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

 

/Helvetica 20 selectfont

70 700 moveto

(Hello world!) show

 

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

 

 

will display the <i>string</i> "(Hello world!)";

 

 

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

 

 

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

 

/Helvetica 20 selectfont

70 700 moveto

show % prints to document

1 0 div % provokes error message

 

=={{header|Potion}}==

 

=={{header|PowerBASIC}}==

#COMPILER PBCC 6

 

CON.PRINT "Hello world!"

CON.WAITKEY$

 

=={{header|PowerShell}}==

 

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

 

=={{header|Processing}}==

 

=={{header|ProDOS}}==

 

=={{header|Programming Language}}==

For typing:

For importing:

 

 

=={{header|Prolog}}==

 

=={{header|PSQL}}==

 

=={{header|Pure}}==

using system;

 

puts "Hello world!\n" ;

 

=={{header|PureBasic}}==

PrintN("Hello world!")

 

=={{header|Python}}==

{{works with|Python|2.4}}

 

The same using sys.stdout

 

In Python 3.0, print is changed from a statement to a function.

 

{{works with|Python|3.0}} (And version 2.X too).

 

'''An easter egg'''

The first two examples print <code>Hello, world!</code> once, and the last one prints it twice.

 

 

 

=={{header|QB64}}==

 

=={{header|Quackery}}==

 

=={{header|Quill}}==

 

=={{header|Quite BASIC}}==

 

=={{header|R}}==

or

or

 

=={{header|Ra}}==

class HelloWorld

**Prints "Hello world!"**

 

print "Hello world!"

 

=={{header|Racket}}==

(printf "Hello world!\n")

 

=={{header|Raku}}==

(formerly Perl 6)

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

 

=={{header|Raven}}==

 

=={{header|REALbasic}}==

This requires a console application.

 

Print "Hello world!"

Quit

 

=={{header|REBOL}}==

 

=={{header|RED}}==

 

 

=={{header|Relation}}==

 

' Hello world!

 

=={{header|REXX}}==

===using SAY===

 

===using SAY variable===

yyy = 'Hello world!'

 

===using LINEOUT===

 

 

=={{header|Ring}}==

 

hello:

.string "Hello World!\n\0"

li a7, 10

ecall

 

=={{header|RTL/2}}==

 

LET NL=10;

RETURN(1);

 

 

=={{header|Ruby}}==

{{works with|Ruby|1.8.4}}

or

or even

 

 

'''Using the > global'''

 

=={{header|Run BASIC}}==

 

=={{header|Rust}}==

fn main() {

print!("Hello world!");

}

 

or

 

fn main() {

println!("Hello world!");

}

 

=={{header|Salmon}}==

 

or

 

 

or

 

 

=={{header|SAS}}==

data _null_;

put "Hello world!";

 

=={{header|SASL}}==

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

'Hello World!",nl

 

=={{header|Sather}}==

main is

#OUT+"Hello world!\n";

end;

 

=={{header|Scala}}==

===Ad hoc REPL solution===

Ad hoc solution as [http://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop REPL] script. Type this in a REPL session:

===Via Java runtime===

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

 

===Via Scala Console API===

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

 

===Short term deviation to out===

===Long term deviation to out===

Console.setErr(Console.out)

Console.err.println ("Err deviated")

 

=={{header|Scheme}}==

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

 

The <tt>display</tt> and <tt>newline</tt> procedures are found in specific modules of the standard library in R6RS and R7RS.

 

===R5RS===

 

===R6RS===

(rnrs io simple (6)))

(display "Hello world!")

 

===R7RS===

(scheme write))

(display "Hello world!")

 

=={{header|Scilab}}==

 

=={{header|ScratchScript}}==

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

 

=={{header|sed}}==

Hello world!

 

=={{header|Seed7}}==

 

const proc: main is func

begin

writeln("Hello world!");

 

=={{header|Self}}==

 

=={{header|SenseTalk}}==

 

=={{header|Set lang}}==

set ! E

set ! L

set ! L

set ! D

 

=={{header|SETL}}==

 

=={{header|SETL4}}==

 

=={{header|Shen}}==

 

=={{header|Shiny}}==

 

=={{header|Sidef}}==

 

=={{header|SimpleCode}}==

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

 

=={{header|SIMPOL}}==

 

=={{header|Simula}}==

{{works with|SIMULA-67}}

OUTTEXT("Hello world!");

OUTIMAGE

 

=={{header|Sisal}}==

 

% Sisal doesn't yet have a string built-in.

function main(returns string)

"Hello world!"

 

=={{header|SkookumScript}}==

Alternatively if just typing in the SkookumIDE [http://skookumscript.com/docs/v3.0/ide/console/workspace/ REPL]:

 

=={{header|Slate}}==