Bienvenue

Cette page regroupe des exemples de Hello World classés par catégories, avec des variantes de versions quand la syntaxe change.

Rechercher un langage ou une version

Résultats visibles : 0

Vieux langages 0

Une sélection de langages historiques avec leur Hello World.

FORTRAN

      PROGRAM HELLO
      PRINT *, 'HELLO WORLD'
      END

COBOL

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
PROCEDURE DIVISION.
    DISPLAY "HELLO WORLD".
    STOP RUN.

BASIC générique

10 PRINT "HELLO WORLD"
20 END

GW-BASIC MS-DOS

10 PRINT "HELLO WORLD"
20 END

QuickBASIC QB 4.5

PRINT "Hello World"
END

Locomotive BASIC Amstrad CPC

10 MODE 2
20 PRINT "HELLO WORLD"
30 END

Commodore BASIC C64 / VIC-20

10 PRINT "HELLO WORLD"
20 END

Sinclair BASIC ZX Spectrum

10 PRINT "HELLO WORLD"
20 STOP

Pascal

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

Turbo Pascal DOS

program Hello;
begin
  WriteLn('Hello World');
end.

ALGOL 68

print(("Hello World", newline))

Lisp Common Lisp

(format t "Hello World~%")

Assembly (NASM, Linux x86-64)

section .data
msg db "Hello World", 10
len equ $ - msg

section .text
global _start
_start:
  mov rax, 1
  mov rdi, 1
  mov rsi, msg
  mov rdx, len
  syscall
  mov rax, 60
  xor rdi, rdi
  syscall

APL

'Hello World'

Ada Ada 2012

with Ada.Text_IO; use Ada.Text_IO;

procedure Hello is
begin
  Put_Line("Hello World");
end Hello;

BCPL

GET "LIBHDR"
LET START() BE
$(
  WRITES("Hello World*n")
$)

Forth

." Hello World" CR

Logo

PRINT [HELLO WORLD]

SNOBOL4

        OUTPUT = 'HELLO WORLD'
END

RPG IBM i free-form

**FREE
dsply ('Hello World');
*inlr = *on;

PL/I

HELLO: PROC OPTIONS(MAIN);
  PUT SKIP LIST('HELLO WORLD');
END HELLO;

Simula

Begin
  OutText("Hello World"); OutImage;
End;

MUMPS

HELLO W "Hello World",!
 Q

Modula-2

MODULE Hello;
FROM InOut IMPORT WriteString, WriteLn;
BEGIN
  WriteString("Hello World");
  WriteLn;
END Hello.

Modula-3

MODULE Hello EXPORTS Main;
import IO;
BEGIN
  IO.Put("Hello World\n");
END Hello.

Oberon

MODULE Hello;
IMPORT Texts, Oberon;
VAR W: Texts.Writer;
PROCEDURE Hello*;
BEGIN
  Texts.WriteString(W, "Hello World");
  Texts.WriteLn(W);
  Texts.Append(Oberon.Log, W.buf)
END Hello;
BEGIN
  Texts.OpenWriter(W)
END Hello.

ALGOL 60

'BEGIN'
  OUTSTRING(1, 'HELLO WORLD');
'END'

COBOL free-form 2002

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
PROCEDURE DIVISION.
    DISPLAY "Hello World"
    STOP RUN.

FORTRAN 77

      PROGRAM HELLO
      WRITE(*,*) 'HELLO WORLD'
      STOP
      END

FORTRAN 90+

PROGRAM Hello
  WRITE(*,*) "Hello World"
END PROGRAM Hello

Atari BASIC Atari 8-bit

10 PRINT "HELLO WORLD"
20 END

MSX BASIC MSX

10 PRINT "HELLO WORLD"
20 END

BBC BASIC BBC Micro / RISC OS

10 PRINT "Hello World"
20 END

TI BASIC TI-83/84

DISP "HELLO WORLD"

HP RPL HP 48/49

"Hello World" MSGBOX

Assembly MASM, Windows x86

.model small
.stack 100h
.data
  msg db 'Hello World', 13, 10, '$'
.code
main proc
  mov ax, @data
  mov ds, ax
  mov dx, offset msg
  mov ah, 09h
  int 21h
  mov ax, 4C00h
  int 21h
main endp
end main

Assembly 6502 (Commodore 64)

; Printed via KERNAL CHROUT
* = $c000
LDA #<msg
STA $fb
LDA #>msg
STA $fc
LDY #0
loop:
  LDA (fb),Y
  BEQ done
  JSR $ffd2
  INY
  BNE loop
done:
  RTS
msg: .text "HELLO WORLD", 0

Assembly Z80 (ZX Spectrum)

ORG 8000h
LD HL, msg
call_loop:
  LD A, (HL)
  CP 0
  JR Z, done
  RST 10h
  INC HL
  JR call_loop
done:
  RET
msg: DEFM "Hello World", 0

Proc Turbo Prolog

goal
  write("Hello World").

Rebol Rebol 2/3

print "Hello World"

Rebol Red dialect

Red [title: "Hello"]
print "Hello World"

Niklaus Wirth PICL

MODULE Hello;
  IMPORT InOut;
BEGIN
  InOut.WriteString("Hello World");
  InOut.WriteLn;
END Hello.

PL/SQL

BEGIN
  DBMS_OUTPUT.PUT_LINE('Hello World');
END;
/

SQL SELECT

SELECT 'Hello World' AS greeting;

TSQL SQL Server

PRINT 'Hello World'

Batch interactive EDLIN

@echo Hello World

INTERCAL

PLEASE DO ,1 <- #13
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
DO ,1 SUB #7 <- #48
DO ,1 SUB #8 <- #22
DO ,1 SUB #9 <- #248
DO ,1 SUB #10 <- #168
DO ,1 SUB #11 <- #24
DO ,1 SUB #12 <- #16
DO ,1 SUB #13 <- #214
PLEASE READ OUT ,1
PLEASE GIVE UP

Brainfuck

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

Whitespace

[Espace][Tab][Espace] = push 72 (H)
... (programme entier en espaces et tabulations)

Malbolge

(\/'Jxa^NYK>-Y!^+{\)$&6T#bG)^T\hnEyZrJ

Befunge-93

"dlroW olleH",,,,,,,,,,,@

Piet

[ programme graphique en pixels colorés — l'image encode Hello World ]

Ook!

Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook.
Ook. Ook. Ook. Ook. Ook. Ook! Ook?

FLOW-MATIC 1955, Grace Hopper

(0) READ-ITEM TAPE-FILE WRITE PRINT-OUT
    STOP

AUTOCODE Edinburgh, 1958

PRINT 'HELLO WORLD'

MAD Michigan Algorithm Decoder, 1959

PRINT FORMAT OUTPUT,'HELLO WORLD'

JOVIAL 1959

START
  PRINT COLUMN 0 , $HELLO WORLD$;
FINISH

NELIAC Naval Electronics Lab, 1958

HELLO: BEGIN PRINT('HELLO WORLD') END

TRAC 1964

#(PS,Hello World)

PL/M Intel 1973

HELLO: DO;
  CALL PRINTSTRING('HELLO WORLD');
END HELLO;

CHILL ITU-T 1980

HELLO: MODULE
  WRITETEXT(STDOUT, 'Hello World');
END HELLO;

Assembly ARM Thumb

.global _start
_start:
  push {r7, lr}
  mov r0, #1
  ldr r1, =msg
  mov r2, #12
  mov r7, #4
  svc #0
  pop {r7, pc}
msg: .ascii "Hello World\n"

Assembly RISC-V (rv64)

.section .data
msg: .string "Hello World\n"
.section .text
.global _start
_start:
  li a7, 64
  li a0, 1
  la a1, msg
  li a2, 12
  ecall
  li a7, 93
  li a0, 0
  ecall

PILOT

T:Hello World

ISWIM 1966, Peter Landin

let main = output "Hello World"

B 1969, Ken Thompson

main( ) {
  putchar('H'); putchar('e'); putchar('l'); putchar('l'); putchar('o');
  putchar(' '); putchar('W'); putchar('o'); putchar('r'); putchar('l'); putchar('d'); putchar('\n');
}

CPL 1963

Write['Hello World']

Coral 66 1970

BEGIN
  PRINT("Hello World");
END

RTL/2 1972

ENT PROCEDURE MAIN();
  TWRITE("Hello World\n");
END;

XPL 1967

DECLARE MSG CHARACTER INITIAL('Hello World');
OUTPUT = MSG;

HAL/S NASA 1973

HELLO: PROGRAM;
  WRITE "Hello World";
CLOSE HELLO;

JOSS 1963

Type "Hello World".

FOCAL PDP-8 1968

01.10 TYPE "Hello World",!

COMAL 1973

PRINT "Hello World"

SNOBOL3 1965

        SYSPOT = 'Hello World'

Icon 1977

procedure main()
  write("Hello World")
end

PL360 1968

BEGIN
  WRITE('Hello World');
END.

TUTOR PLATO IV 1973

write   Hello World

Lisp 1.5 1959

(PRIN1 (QUOTE (HELLO WORLD)))

MACLISP PDP-10 1966

(print 'Hello\ World)

Interlisp 1967

(PRINT "Hello World")

Scheme RRS 1975

(display "Hello World")

DIBOL DEC 1970

PROC
  XCALL FLAGS (0000000)
  DISPLAY (1, "Hello World")
  STOP
END

Minitel Videotex

PROG:
  PRINT "Hello World"
  RETURN

Sinclair QL SuperBASIC

PRINT "Hello World"

OPL Psion Organiser

PROC main:
  PRINT "Hello World"
  GET
ENDP

AMOS BASIC Amiga 1990

Print "Hello World"

ST BASIC Atari ST 1985

10 PRINT "Hello World"
20 END

GFA BASIC 1986

PRINT "Hello World"

DarkBASIC Retro 3D

print "Hello World"
wait key

Blitz BASIC Amiga 1989

NPrint "Hello World"
MouseWait
End

True BASIC 1985

PRINT "Hello World"
END

Altair BASIC 1975

10 PRINT "HELLO WORLD"

QBasic 1.1 MS-DOS 1991

PRINT "Hello World"

PowerBASIC

FUNCTION PBMAIN () AS LONG
  STDOUT "Hello World"
END FUNCTION

XBasic

PROGRAM "Hello"
VERSION "1.0"
DECLARE FUNCTION Entry()
FUNCTION Entry()
  PRINT "Hello World"
END FUNCTION
END PROGRAM

Yabasic

print "Hello World"

Euphoria 1993

puts(1, "Hello World\n")

Turing 1982

put "Hello World"

Oberon-2

MODULE Hello;
IMPORT Out;
BEGIN
  Out.String("Hello World"); Out.Ln
END Hello.

Component Pascal

MODULE Hello;
IMPORT StdLog;
BEGIN
  StdLog.String("Hello World"); StdLog.Ln
END Hello.

BLISS 1970

MODULE HELLO(MAIN=HELLO_MAIN) =
BEGIN
  ROUTINE HELLO_MAIN =
  BEGIN
    EXTERNAL ROUTINE PUTS;
    PUTS('Hello World');
  END;
END
ELUDOM

Assembly MACRO-11 (PDP-11)

  .MCALL  .PRINT,.EXIT
START:  .PRINT  #MSG
        .EXIT
MSG:    .ASCIZ  /Hello World/
        .END    START

Assembly MACRO-10 (PDP-10)

TITLE HELLO
START:  OUTSTR [ASCIZ /Hello World
/]
        EXIT
        END START

Assembly BAL (IBM 360)

HELLO    CSECT
         USING *,15
         WTO   'Hello World'
         BR    14
         END   HELLO

Autocoder IBM 1401

        JOB  HELLO
        CTL  6644
        ORG  087
EX      W    MSG
        H    EX
MSG     DCW  @HELLO WORLD@
        END  EX

Assembly LR35902 (Game Boy)

; (Routine de texte basique)
ld hl, HelloWorldText
call PrintString
HelloWorldText:
  db "Hello World!", 0

Assembly 65816 (SNES)

LDA #$01
LDX #HelloWorldText
JSL PrintText

Assembly Motorola 68000

  MOVE.W #9,-(SP)
  PEA MSG
  TRAP #1
  ADDQ.L #6,SP
  CLR.W -(SP)
  TRAP #1
MSG:
  DC.B 'Hello World',13,10,0

MIXAL Donald Knuth 1968

TERM    EQU    19
        ORIG   1000
START   OUT    MSG(TERM)
        HLT
MSG     ALF    "HELLO"
        ALF    " WORL"
        ALF    "D    "
        END    START

MMIXAL Donald Knuth 1999

        LOC   Data_Segment
        GREG  @
Msg     BYTE  "Hello World",10,0
        LOC   #100
Main    LDA   $255,Msg
        TRAP  0,Fputs,StdOut
        TRAP  0,Halt,0

LOLCODE Esoteric

HAI 1.2
CAN HAS STDIO?
VISIBLE "Hello World"
KTHXBYE

Chef Esoteric

Hello World Souffle.
Ingredients.
72 g haricot beans
101 eggs
108 g lard
... (Recettes générant de l'ASCII)

SPL Shakespeare

Romeo, a young man with a remarkable patience.
Juliet, a likewise young woman of remarkable grace.
[Enter Romeo and Juliet]
Romeo: Speak your mind! ...

Deadfish Esoteric

iisiiiisiiiiiiiiciiiiiiiiiic...

Hexagony Esoteric

   H ; e ;
  l ; d ; *
 ; r ; o ; W
l ; ; o ; *
 ; ; ; ; ;
  ; ; ; ;
   ; ; ;

ArnoldC Esoteric

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

TrumpScript Esoteric

say "Hello World"!
America is great.

BIT Esoteric

LINE HEADER LENGTH 3
PRINT "Hello World"

INTERCAL-72 1972

DO ,1 <- #13
PLEASE DO ,1 SUB #1 <- #238
...

FALSE Esoteric 1993

"Hello World
"

Bloop Hofstadter 1979

DEFINE PROCEDURE ''HELLO'' [N]:
BLOCK 0: BEGIN
  PRINT ['Hello World']
BLOCK 0: END.

Plankalkül Zuse 1948

R1.1 => R0
| 'H','e','l','l','o',' ','W','o','r','l','d' => Druckwerk

Short Code 1950

00 X3 =  0  07 X3 = X3 + 1
   PRINT 'HELLO WORLD'

Speedcoding IBM 701 1953

PRINT HELLO WORLD

IPL Info Processing 1956

J0 HELLO WORLD
H0 PRINT J0

COMIT NLP 1957

HELLO = 'HELLO WORLD' / PRINT

MATH-MATIC Univac 1957

PRINT 'HELLO WORLD'

FACT 1959

OUTPUT HELLO WORLD

Atlas Autocode 1961

print £HELLO WORLD£

Dartmouth BASIC 1964

10 PRINT "HELLO WORLD"
20 END

ALGOL W 1966

BEGIN
  WRITE("HELLO WORLD")
END.

POP-2 1967

vars hello;
'Hello World' -> hello;
hello =>

POP-11 1975

'Hello World' =>

SETL 1969

print("Hello World");

STOIC Stack-based 1977

." Hello World" CR

DIBOL DEC 1970

XCALL MSG("Hello World")

Edinburgh IMP 1966

%BEGIN
PRINTSTRING("HELLO WORLD")
NEWLINE
%END

SAIL Stanford 1969

BEGIN
  PRINT("HELLO WORLD");
END;

Mesa Xerox PARC 1976

Hello: PROGRAM =
BEGIN
  Put.Text["Hello World"];
END.

Cedar Xerox 1983

IO.PutRope["Hello World\n"];

Micro-PLANNER 1969

(THPRINT "Hello World")

CONNIVER MIT 1972

(PRINT "Hello World")

SAM76 Macro 1976

\OUT Hello World

TECO Editor 1962

IHello World$HT$$

GEORGE 1957

P (Hello World) ;

JOHNNIAC RAND 1953

TYPE HELLO WORLD

SOAP IBM 650 Assembler

HLW 8001 HELLO WORLD

TRAC Mooers 1964

#(PS,Hello World)

Telcomp BBN 1965

1.1 TYPE "HELLO WORLD"

JOSS RAND 1963

Type "Hello World".

MAD Michigan 1959

PRINT COMMENT $HELLO WORLD$

NELIAC Navy 1955

OUTPUT 'HELLO WORLD'

GPSS Simulation 1961

GENERATE ,,1
TERMINATE 1
; Hello World sim

Simula I 1962

BEGIN
  OUTTEXT("Hello World");
  OUTIMAGE;
END

CPL Cambridge 1963

WriteString("Hello World")

COWSEL Edinburgh 1966

(PRINT 'HELLO WORLD)

B Thompson 1969

main() {
  putstr("Hello World*n");
}

BLISS CMU 1970

MODULE Hello =
BEGIN
  EXTERNAL ROUTINE puts;
  puts(UPLIT('Hello World'));
END
ELUDOM

Ratfor Rational Fortran

print *, 'Hello World'
end

AED Automated Eng. 1965

WRITE 'HELLO WORLD';

FORMAC IBM Math 1962

PRINT 'HELLO WORLD'

PPL Polymorphic 1969

PRINT "Hello World"

MDL MIT 1971

<PRINC "Hello World">

Lucid Dataflow 1974

hello = "Hello World";>>

TUTOR PLATO 1969

write    Hello World

LOGO (MIT) Papert 1967

PRINT [HELLO WORLD]

BASIC (HP) HP 2000 1968

10 PRINT "HELLO WORLD"
20 END

TELCOMP II BBN 1969

1.1 T "HELLO WORLD"

PLANNER MIT AI 1969

(THGOAL (PRINT |HELLO WORLD|))

CONNIVER MIT 1972

(PRINT "HELLO WORLD")

SAIL Stanford AI 1969

PRINT("HELLO WORLD");

ISWIM Landin 1966

let hello = "Hello World" in print hello

PAL MIT 1967

PRINT 'HELLO WORLD'

JOVIAL J73 MIL-STD

PROC MAIN;
  PRINT 'HELLO WORLD';
END;

SPL HP 3000 1972

BEGIN
  PRINT("HELLO WORLD");
END.

IMP Edinburgh 1966

%BEGIN
PRINTSTRING("HELLO WORLD")
%END

Atlas Autocode Manchester 1961

print "HELLO WORLD"

Edinburgh IMP 1970

%BEGIN
%PRINTTEXT "HELLO WORLD"
%END

GEORGE Univ. Sydney 1957

P HELLO WORLD

Autocode Manchester 1952

PRINT HELLO WORLD

FLOW-MATIC Hopper 1955

DISPLAY HELLO WORLD

Short Code UNIVAC 1950

00 HELLO WORLD

MATH-MATIC UNIVAC 1957

PRINT 'HELLO WORLD'

COMIT MIT NLP 1957

HELLO + WORLD = PRINT

NELIAC Navy 1955

PRINT('HELLO WORLD');

Plankalkül Zuse 1948

R1.1() => "HELLO WORLD"

Speedcoding IBM 701 1953

PRINT HELLO WORLD

IT Internal Translator 1956

OUTPUT HELLO WORLD

GRAD Grinnell 1964

WRITE 'HELLO WORLD'

MAP Macro Assembly 1961

MSG HELLO WORLD

Laning-Zierler MIT 1952

PRINT HELLO WORLD

BACAIC Boeing 1955

DISPLAY HELLO WORLD

TRAC 1964 Macro

#(PS,Hello World)

REFAL 1966 Pattern

$ENTRY Go { = <Prout 'Hello World'> }

BCPL Richards 1967

GET "LIBHDR"
LET START() BE
  WRITES("Hello World")

B Thompson 1969

main() {
  putstr("Hello World!*n");
}

BLISS CMU 1970

MODULE HELLO =
BEGIN
  EXTERNAL ROUTINE PUTS;
  PUTS(UPLIT('Hello World'));
END

POP-2 Edinburgh 1967

'Hello World' =>

TECO PDP Editor 1962

IHello World$

EXEC 2 IBM VM 1966

&TYPE Hello World

Ratfor Rational Fortran 1974

print *, 'Hello World'
end

DIBOL DEC 1970

PROC
  DISPLAY(0:15,"Hello World")
END

TAL Tandem 1974

PROC HELLO MAIN;
BEGIN
  CALL WRITE("Hello World");
END;

STOIC Stack 1970

:HELLO ." Hello World" CR ;
HELLO

PILOT 1962 CAI

T:Hello World

FOCAL DEC 1968

01.10 TYPE "Hello World" !

DIBOL II DEC 1975

DISPLAY(0:15,"Hello World")

CHILL CCITT 1980

hello: PROC ();
  WRITETEXT(STDOUT, "Hello World%%/");
END hello;

Euclid Toronto 1977

procedure Hello
  put "Hello World"
end Hello

CLU MIT Liskov 1975

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

ICL 1900 Plan 1964

OUTPUT 'HELLO WORLD'

CDC 6600 Compass 1964

HELLO WORLD

ICES STRUDL MIT 1967

PRINT 'HELLO WORLD'

IBM 1620 SPS 1960

TFM HELLO WORLD

TELCOMP BBN 1965

1.1 TYPE HELLO WORLD

AIMACO Air Force 1959

DISPLAY HELLO WORLD

CORC Cornell 1962

PRINT, HELLO WORLD

MAD Michigan 1959

PRINT FORMAT RESULT,HELLO WORLD
VECTOR VALUES RESULT=$6HHELLO  WORLD*$

WATFOR Waterloo 1965

      PRINT, 'HELLO WORLD'
      STOP
      END

Hexadécimal Raw Hex Bytes

48 65 6C 6C 6F 20 57 6F 72 6C 64
(H  e  l  l  o     W  o  r  l  d)

Binaire Raw Binary

01001000 01100101 01101100 01101100 01101111
00100000 01010111 01101111 01110010 01101100 01100100
(Hello World en ASCII binaire)

Octal Base 8

110 145 154 154 157 040 127 157 162 154 144
(H   e   l   l   o   " "  W   o   r   l   d)

Base64 Encodage

SGVsbG8gV29ybGQ=
("Hello World" encodé en Base64)

ASCII Décimal Code Points

72 101 108 108 111 32 87 111 114 108 100
(H  e   l   l   o      W  o   r   l   d)

Unicode Code Points

U+0048 U+0065 U+006C U+006C U+006F
U+0020 U+0057 U+006F U+0072 U+006C U+0064

Morse Code télégraphique

.... . .-.. .-.. ---   .-- --- .-. .-.. -..
(H    E L    L    O     W   O   R   L    D)

Langages objet 0

Exemples Hello World en langages orientés objet.

Java JDK 8+

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

Java JShell

System.out.println("Hello World");

C# .NET 6+ top-level

Console.WriteLine("Hello World");

C# style classique

using System;

class Program {
  static void Main() {
    Console.WriteLine("Hello World");
  }
}

C++ C++11+

#include <iostream>

int main() {
  std::cout << "Hello World" << std::endl;
  return 0;
}

Objective-C

#import <Foundation/Foundation.h>

int main() {
  @autoreleasepool {
    NSLog(@"Hello World");
  }
  return 0;
}

Smalltalk

Transcript show: 'Hello World'; cr.

Ruby

puts 'Hello World'

Visual Basic VB.NET

Module Program
    Sub Main(args As String())
        Console.WriteLine("Hello World")
    End Sub
End Module

Visual Basic VBA

Sub Hello()
    MsgBox "Hello World"
End Sub

Kotlin

fun main() {
  println("Hello World")
}

Swift

print("Hello World")

Scala 2/3

object Main extends App {
  println("Hello World")
}

Delphi Object Pascal

program Hello;

begin
  Writeln('Hello World');
end.

Eiffel

class
  HELLO

create
  make

feature
  make
    do
      io.put_string ("Hello World%N")
    end
end

Dylan

format-out("Hello World\n");

Pharo Smalltalk Workspace

Transcript show: 'Hello World'; cr.

Julia OO style (struct)

struct Greeter
  text::String
end

println(Greeter("Hello World").text)

Dart class style

class Greeter {
  final String msg;
  Greeter(this.msg);
}

void main() => print(Greeter('Hello World').msg);

TypeScript class

class Greeter {
  constructor(private message: string) {}
  hello() { console.log(this.message); }
}

new Greeter('Hello World').hello();

Ceylon

shared void run() {
  print("Hello World");
}

Io

"Hello World" println

Groovy Groovy 4

class Hello {
  static void main(String[] args) {
    println "Hello World"
  }
}

ActionScript AS3

package {
  import flash.display.Sprite;
  public class Main extends Sprite {
    public function Main() {
      trace("Hello World");
    }
  }
}

Apex Salesforce

System.debug('Hello World');

Powershell OO style

class Greeter {
  [string]$Msg
  Greeter([string]$m) { $this.Msg = $m }
  Say() { Write-Output $this.Msg }
}
[Greeter]::new('Hello World').Say()

Perl 6 / Raku OO

class Greeter {
  has $.msg;
  method hello { say $.msg }
}
Greeter.new(msg => 'Hello World').hello;

Magik GE Smallworld

write("Hello World")

Self

'Hello World' printNl.

Newspeak

class HelloWorld usingPlatform: p = (
  HelloWorld new printHello.
) (
  printHello = (
    system out println: 'Hello World'.
  )
)

Wren

System.print("Hello World")

Cobra

class Hello
    def main
        print 'Hello World'

Boo

print "Hello World"

Xtend

class Hello {
  def static void main(String[] args) {
    println("Hello World")
  }
}

Fantom

class Main {
  Void main() { echo("Hello World") }
}

Groovy Script

println "Hello World"

Nice

void main(String[] args) throws Exception {
  System.out.println("Hello World");
}

Lasso

"Hello World"

Oxygene

namespace Hello;
type
  Hello = class
  public
    class method Main;
  end;
implementation
class method Hello.Main;
begin
  writeLn('Hello World');
end;

Java records (21+)

record Hello(String msg) {
  public static void main(String... args) {
    System.out.println(new Hello("Hello World").msg());
  }
}

Hack Facebook/Meta

<?hh
<<__EntryPoint>>
function main(): void {
  echo "Hello World\n";
}

Haxe Java target

class Main {
  static function main() {
    trace("Hello World");
  }
}

Mirah

puts "Hello World"

Gosu

print("Hello World")

Kotlin Android Toast

Toast.makeText(this, "Hello World", Toast.LENGTH_SHORT).show()

Swift SwiftUI

import SwiftUI
struct ContentView: View {
  var body: some View {
    Text("Hello World")
  }
}

Objective-C++ .mm

#import <Foundation/Foundation.h>
#include <iostream>
int main() {
  std::cout << "Hello World" << std::endl;
  return 0;
}

Java Jakarta EE servlet

@WebServlet("/hello")
public class Hello extends HttpServlet {
  protected void doGet(req, res) throws Exception {
    res.getWriter().println("Hello World");
  }
}

C# ASP.NET Minimal API

var app = WebApplication.Create();
app.MapGet("/", () => "Hello World");
app.Run();

Ring

see "Hello World" + nl

Ioke

"Hello World" println

Fancy

"Hello World" println

Nu

(puts "Hello World")

Zimbu

FUNC Main() void
  IO.write("Hello World\n")
}

Lava visual OO

// Lava est visuel ; équivalent textuel :
output("Hello World")

ABAP SAP

REPORT ZHELLO.
WRITE: / 'Hello World'.

4D

ALERT("Hello World")

Harbour xBase

? "Hello World"

xBase / dBASE

? "Hello World"

Clipper 1985

? "Hello World"

FoxPro / Visual FoxPro

? "Hello World"

Unified Parallel C UPC

#include <upc.h>
#include <stdio.h>
int main() {
  printf("Hello World\n");
  return 0;
}

Squeak Smalltalk

Transcript show: 'Hello World'; cr.

Pharo Smalltalk

Transcript show: 'Hello World'.

GNU Smalltalk

'Hello World' printNl.

AmigaE

println("Hello World")

Vala GNOME

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

Genie GNOME

init
    print "Hello World"

Chapel Class method

class Hello {
  proc greet() { writeln("Hello World"); }
}
var h = new unmanaged Hello();
h.greet();
delete h;

Dylan OO / Functional

define method main ()
  format-out("Hello World\n");
end method main;
main();

Modula-3 OO Features

MODULE Hello EXPORTS Main;
IMPORT IO;
BEGIN
  IO.Put("Hello World\n");
END Hello.

Pony Actor model

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

Eiffel Design by Contract

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

Sather

class HELLO is
  main is
    #OUT+"Hello World\n";
  end;
end;

Beta

(#
  do 'Hello World\n' -> putString;
#)

Agora

"Hello World" println

Cecil

var x : string := "Hello World";
x.print_line();

Nemerle

System.Console.WriteLine("Hello World");

Obix

console.write("Hello World");

Pike

int main() {
  write("Hello World\n");
  return 0;
}

Savi

:class Main
  :new (env)
    env.out.print("Hello World")

Seed7

#include "seed7_05.s7i";
const proc: main is func
begin
  writeln("Hello World");
end func;

TADS 3

main(args) {
    tadsSay('Hello World');
}

Xtend

class Hello {
  def static void main(String[] args) {
    println("Hello World")
  }
}

Visual Basic .NET

Module Hello
  Sub Main()
    Console.WriteLine("Hello World")
  End Sub
End Module

PowerBuilder

MessageBox("Hello", "Hello World")

Gosu Class

class Hello {
  static function main(args: String[]) {
    print("Hello World")
  }
}

Fantom

class Hello {
  static Void main() {
    echo("Hello World")
  }
}

Lasso

log('Hello World')

MaxScript

print "Hello World"

Oxygene Object Pascal

namespace HelloWorld;
interface
type
  ConsoleApp = class
  public
    class method Main(args: array of String);
  end;
implementation
class method ConsoleApp.Main(args: array of String);
begin
  Console.WriteLine('Hello World');
end;
end.

Xojo

MessageBox("Hello World")

Clarion

MESSAGE('Hello World')

JScript

print "Hello World"

LiveScript

console.log 'Hello World'

ActionScript 3

package {
  import flash.display.Sprite;
  public class Hello extends Sprite {
    public function Hello() {
      trace("Hello World");
    }
  }
}

Apex Salesforce

System.debug('Hello World');

Processing

println("Hello World");

NewtonScript

Print("Hello World");

ColdFusion CFC

component {
  public void function sayHello() {
    WriteOutput("Hello World");
  }
}

EGL

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

Flavors MIT OO Lisp 1979

(defflavor hello () ())
(defmethod (hello :say) ()
  (format t "Hello World~%"))

LOOPS Xerox 1983

(SendMessage Hello Say "Hello World")

OORexx IBM

say "Hello World"

AspectJ Java AOP

public aspect HelloAspect {
  before(): execution(* main(..)) {
    System.out.println("Hello World");
  }
}

XOTcl Extended OTcl

Class Hello
Hello instproc say {} { puts "Hello World" }
Hello create h; h say

Object COBOL Micro Focus

CLASS-ID. Hello.
METHOD-ID. Say.
  DISPLAY "Hello World"
END METHOD Say.
END CLASS Hello.

SubL Cyc KB

(format t "Hello World~%")

POOL Parallel OO 1987

BODY Hello
  ROUTINE Run
    OUTPUT "Hello World"
  END Run
END Hello

TOOL Telcomp OO

OBJECT Hello
  METHOD Say
    PRINT "Hello World"
  END METHOD
END OBJECT

Noop Google Exp.

class Hello {
  String say() { return "Hello World"; }
}

Objective-J Cappuccino

@implementation Hello : CPObject
- (void)say { CPLog("Hello World"); }
@end

Dao OO Scripting

io.writeln( "Hello World" )

Agora Prototype OO

'Hello World' print

Leda Multi-Paradigm

program hello;
begin writeln('Hello World') end.

Converge OO + Icons

import Sys
func main():
  Sys::println("Hello World")

Magpie Pattern OO

print("Hello World")

Grace Edu OO

print "Hello World"

Encore Actor OO

class Main
  def main() : unit
    println("Hello World")
  end
end

X10 IBM Parallel OO

public class Hello {
  public static def main(args:Rail[String]) {
    Console.OUT.println("Hello World");
  }
}

Theta MIT OO 1994

hello = proc()
  typecase "Hello World" as s:string
    stream$putl(stdout, s)
  end
end

Rapira Soviet OO

ПРОЦ СТАРТ()
  ВЫВОД: "Hello World"
КНЦ

GJ Generic Java

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

Pizza Java Generics

class Hello {
  static void main(String[] args) {
    System.out.println("Hello World");
  }
}

J++ Microsoft Java

public class Hello {
  public static void main(String[] a) {
    System.out.println("Hello World");
  }
}

Curl MIT Web OO

{text Hello World}

Lingo Macromedia Director

put "Hello World"

Yoix Sun Scripting OO

printf("Hello World\n");

Umple Model OO

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

Fortress Sun Multi OO

component Hello
  export Executable
  run() = println "Hello World"
end

Chapel Cray OO

class Hello {
  proc say() { writeln("Hello World"); }
}
var h = new Hello();
h.say();

ParaSail Parallel OO

func Hello() is
  Println("Hello World")
end func Hello

Sather ICSI OO

class HELLO is
  main is
    #OUT + "Hello World\n";
  end;
end;

Trellis/Owl DEC OO

class Hello
  method say : String is
    return "Hello World"
  end
end

ZetaLisp MIT Lisp OO

(format t "Hello World~%")

CLOS Common Lisp OO

(defclass hello () ())
(defmethod say ((h hello))
  (format t "Hello World~%"))
(say (make-instance 'hello))

Emerald Distributed OO

const Hello <- object Hello
  process stdout.PutString["Hello World"]
end Hello

Scala 3 OO Fusion

@main def hello() = println("Hello World")

Kotlin 2 Modern OO

fun main() = println("Hello World")

Java 21 Modern Java

void main() {
  System.out.println("Hello World");
}

C# 12 Top-level

Console.WriteLine("Hello World");

Dart 3 Flutter OO

void main() => print('Hello World');

TypeScript 5 Strict OO

const msg: string = "Hello World";
console.log(msg);

Pharo 12 Modern Smalltalk

Transcript show: 'Hello World'

Squeak Smalltalk VM

Transcript show: 'Hello World'

VisualAge IBM Smalltalk

Transcript show: 'Hello World'

GNU Smalltalk CLI

Transcript show: 'Hello World'

Boo .NET Python-like

print "Hello World"

Fantom JVM/.NET

class Main {
  static Void main() { echo("Hello World") }
}

Gosu JVM OO

print("Hello World")

X10 IBM Parallel

public class Hello {
  public static def main(Rail[String]) {
    Console.OUT.println("Hello World");
  }
}

Fortress Sun Parallel

component Hello
  export Executable
  run() = println("Hello World")
end

Newspeak Bracha OO

class Hello = (
  public main: platform = (
    platform console println: 'Hello World'.
  )
)

Lasso Web OO

'Hello World'

Oxygene Delphi .NET

class method Hello.Main;
begin
  writeLn('Hello World');
end;

Spec# Microsoft Research

class Hello {
  static void Main() {
    System.Console.WriteLine("Hello World");
  }
}

Nice JVM Multi-dispatch

void main(String[] args) {
  println("Hello World");
}

Self Prototype OO

'Hello World' printLine

Io Prototype Lang

"Hello World" println

Ioke JVM Prototype

"Hello World" println

Slate Prototype Multi

inform: 'Hello World'.

Magik GE Smallworld

write("Hello World")

BETA Scandinavian OO

(# do 'Hello World' -> putline #)

Simscript CACI

MAIN
  PRINT 1 LINE THUS
  Hello World
END

Clarion SoftVelocity

PROGRAM
  MAP
  END
  CODE
  MESSAGE('Hello World')

PowerBuilder Appeon

MessageBox('Greeting', 'Hello World')

Xojo Cross-platform

MsgBox "Hello World"

Gambas Linux BASIC OO

Public Sub Main()
  Print "Hello World"
End

Harbour OO xBase Class

CLASS Hello
  METHOD show() INLINE ? "Hello World"
ENDCLASS

OpenObject Odoo Python

class Hello:
    def hello(self):
        print("Hello World")

Polymer Google WC

class Hello extends PolymerElement {
  static get template() {
    return html`<p>Hello World</p>`;
  }
}

Objective-J Cappuccino

@implementation Hello : CPObject
- (void)sayHello {
  CPLog("Hello World");
}
@end

RealBasic Xojo Legacy

MsgBox "Hello World"

Oberon-2 Wirth OO

MODULE Hello;
IMPORT Out;
BEGIN
  Out.String("Hello World"); Out.Ln;
END Hello.

Component Pascal BlackBox

MODULE Hello;
IMPORT Log;
BEGIN
  Log.String("Hello World"); Log.Ln;
END Hello.

Active Oberon ETH

MODULE Hello;
IMPORT KernelLog;
BEGIN
  KernelLog.String("Hello World");
END Hello.

Zonnon .NET Oberon

module Hello;
import System;
begin
  System.Console.WriteLine("Hello World");
end Hello.

Modula-2 OO p1 Extension

MODULE Hello;
FROM InOut IMPORT WriteString, WriteLn;
BEGIN
  WriteString("Hello World"); WriteLn;
END Hello.

AmigaE Amiga OO

PROC main()
  WriteF('Hello World\n')
ENDPROC

Curl Web OO

{curl 7.0 applet}
{value "Hello World"}

Unicon Icon OO

procedure main()
  write("Hello World")
end

XOTcl Tcl OO

puts "Hello World"

Pike LPC OO

int main() {
  write("Hello World\n");
  return 0;
}

Langages classiques 0

Hello World des langages généralistes très utilisés.

C

#include <stdio.h>

int main(void) {
  printf("Hello World\\n");
  return 0;
}

Go

package main

import "fmt"

func main() {
  fmt.Println("Hello World")
}

Rust

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

D

import std.stdio;

void main() {
  writeln("Hello World");
}

Zig

const std = @import("std");

pub fn main() !void {
  try std.io.getStdOut().writer().print("Hello World\\n", .{});
}

Nim

echo "Hello World"

Julia

println("Hello World")

Dart

void main() {
  print('Hello World');
}

Crystal

puts "Hello World"

V

fn main() {
    println('Hello World')
}

Odin

package main

import "core:fmt"

main :: proc() {
    fmt.println("Hello World")
}

Carbon expérimental

package Hello api;

fn Main() -> i32 {
  Print("Hello World");
  return 0;
}

Ada/SPARK subset

with Ada.Text_IO; use Ada.Text_IO;

procedure Main is
begin
  Put_Line("Hello World");
end Main;

Hare

use fmt;

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

Chapel

writeln("Hello World");

Pony

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

Vala

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

Haxe

class Main {
  static function main() {
    trace("Hello World");
  }
}

ATS

implement main0 () = print("Hello World\n")

Terra

C.printf("Hello World\n")

Red

print "Hello World"

Fortran 2008 coarray

program Hello
  write(*,*) 'Hello World'
end program

Mojo 0.x

fn main():
    print("Hello World")

Beef

using System;

class Program {
  static void Main() {
    Console.WriteLine("Hello World");
  }
}

Lobster

print "Hello World"

Wren

System.print("Hello World")

Nelua

print 'Hello World'

Roc

app "hello" provides [main] to "./platform"
main = Stdout.line "Hello World"

Futhark

-- (Futhark ne fait pas I/O directive, equiv via runtime)
let main = "Hello World"

GLSL fragment shader

// GLSL n'affiche pas de texte, mais convention Hello World:
void main() {
  gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0); // blanc = "bonjour"
}

HLSL

float4 main() : SV_Target {
  return float4(1, 1, 1, 1);
}

WGSL WebGPU

@fragment
fn main() -> @location(0) vec4f {
  return vec4f(1.0, 1.0, 1.0, 1.0);
}

Metal Apple GPU

#include <metal_stdlib>
using namespace metal;
fragment float4 hello() { return float4(1,1,1,1); }

OpenCL C

__kernel void hello(__global char* out) {
  // "Hello World" placé en mémoire côté host
  out[0] = 'H';
}

CUDA C++

#include <cstdio>
__global__ void kernel() {
  printf("Hello World\n");
}
int main() {
  kernel<<<1,1>>>();
  cudaDeviceSynchronize();
}

Cython

print("Hello World")

C C89

#include <stdio.h>
int main(void) {
  printf("Hello World\n");
  return 0;
}

C C99 variadic

#include <stdio.h>
int main(void) {
  puts("Hello World");
  return 0;
}

C C23 embed

#include <stdio.h>
int main(void) {
  static const char msg[] = { #embed "hello.txt" };
  puts(msg);
}

C++ C++20 modules

import <iostream>;
int main() {
  std::println("Hello World");
}

C++ C++23 std::print

#include <print>
int main() {
  std::print("Hello World\n");
}

Go generics 1.18+

package main
import "fmt"
func print[T any](v T) { fmt.Println(v) }
func main() { print("Hello World") }

Rust macro format!

fn main() {
  print!("{}", "Hello World");
}

Rust no_std

#![no_std]
#![no_main]
use core::fmt::Write;
// (impl via UART write)

Zig 0.12+ comptime

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

D dietlang subset

import std.stdio;
void main() { writeln("Hello World"); }

Nim compile-time

static: echo "Hello World"

Swift async/await main

@main struct Hello {
  static func main() async {
    print("Hello World")
  }
}

Kotlin Multiplatform

expect fun hello(): String
fun main() { println(hello()) }

Dart Flutter widget

import 'package:flutter/material.dart';
void main() => runApp(MaterialApp(
  home: Scaffold(body: Center(
    child: Text('Hello World')))));

Julia macro

macro hello(); :(println("Hello World")); end
@hello

Starlark Buck2

print("Hello World")

Vale

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

Ante

print "Hello World"

Austral

module Hello is
  function Main(): ExitCode is
    printLn("Hello World");
    return ExitSuccess();
  end;
end.

Unison

main : '{IO} ()
main = printLine "Hello World"

Grain

module Main
include "print" from "sys/print"
print("Hello World")

Inko

class async Main {
  fn async main {
    STDOUT.new.print('Hello World\n')
  }
}

Odin

package main
import "core:fmt"
main :: proc() {
  fmt.println("Hello World")
}

V (Vlang)

fn main() {
  println('Hello World')
}

Jai Jonathan Blow

#import "Basic";
main :: () {
  print("Hello World\n");
}

Crystal Ruby-like compiled

puts "Hello World"

Pony Compile-time safe

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

Hare

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

Ring Innovative script

see "Hello World\n"

Red Rebol descendant

Red []
print "Hello World"

Myrddin

use std
const main = {
  std.put("Hello World\n")
}

Chapel Iterators

writeln("Hello World");

Nim compiled

echo "Hello World"

Vala

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

Aldor

#include "aldor"
#include "aldorio"
stdout << "Hello World" << newline;

Gleam

import gleam/io
pub fn main() {
  io.println("Hello World")
}

Haxe C++ target

class Main {
  static function main() {
    Sys.println("Hello World");
  }
}

Neko

$print("Hello World\n");

ATS

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

Mercury

:- module hello.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
main(!IO) :-
    io.write_string("Hello World\n", !IO).

Erlang Compiled

-module(hello).
-export([start/0]).
start() -> io:fwrite("Hello World\n").

Rust 1.0

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

Go 1.0

package main
import "fmt"
func main() {
    fmt.Println("Hello World")
}

D v2

import std.stdio;
void main() {
    writeln("Hello World");
}

Awk

BEGIN { print "Hello World" }

BQN

"Hello World"

Uiua

&p "Hello World"

K Kx Systems

`0:"Hello World\n"

Q kdb+

-1 "Hello World";

Nit

print "Hello World"

Fennel Lua Lisp

(print "Hello World")

Janet

(print "Hello World")

Elm 0.19

import Html exposing (text)
main = text "Hello World"

PureScript

module Main where
import Effect.Console (log)
main = log "Hello World"

Mojo Modular

fn main():
    print("Hello World")

Beef

using System;
class Program {
  static void Main() {
    Console.WriteLine("Hello World");
  }
}

Nelua

print 'Hello World'

ABC Python Ancestor

WRITE "Hello World" /

PL/0 Wirth Educational

! Hello World.

Modula-1 Wirth 1975

MODULE Hello;
  PROCEDURE WriteHello;
  BEGIN WriteString('Hello World'); WriteLn
  END WriteHello;
BEGIN WriteHello
END Hello.

S R Predecessor 1976

cat("Hello World\n")

Euclid Verified 1977

begin
  put "Hello World"
end

CLU Liskov 1975

start_up = proc ()
  stream$putl(stream$primary_output(), "Hello World")
end start_up

Caml Light 1990

print_string "Hello World\n";;

Oberon-07 Wirth 2007

MODULE Hello;
  IMPORT Out;
BEGIN Out.String("Hello World"); Out.Ln
END Hello.

Component Pascal BlackBox

MODULE Hello;
  IMPORT StdLog;
BEGIN StdLog.String("Hello World")
END Hello.

ALGOL 58 IAL

BEGIN
OUTPUT ('HELLO WORLD')
END

Codon Python Compiler

print("Hello World")  # Codon compiled

Pawn Embedded Scripting

main()
  printf("Hello World\n")

LPC MUD Lang

void create() {
  write("Hello World\n");
}

DM BYOND Dream Maker

mob/Login()
  world << "Hello World"

ALGOL-M 1968

BEGIN
  WRITE("HELLO WORLD");
END.

PL/C Cornell 1971

HELLO: PROCEDURE OPTIONS(MAIN);
  PUT LIST('Hello World');
END HELLO;

Algol-like ALGOL-N

begin write("Hello World"); end.

NewLISP Scripting

(println "Hello World")

Harbour xBase Compiler

FUNCTION Main()
  ? "Hello World"
RETURN NIL

PureBasic 3D Cross-platform

Debug "Hello World"

PowerBASIC Windows

FUNCTION PBMAIN()
  PRINT "Hello World"
END FUNCTION

Seed7 Extensible

$ include "seed7_05.s7i";
const proc: main is func
  begin writeln("Hello World");
  end func;

Icon Goal-directed

procedure main()
  write("Hello World")
end

Unicon Icon successor

procedure main()
  write("Hello World")
end

SNOBOL4 Pattern Matching

  OUTPUT = "Hello World"
END

Mumps / M Medical

HELLO ; M routine
  WRITE "Hello World",!
  QUIT

REXX IBM Scripting

say "Hello World"

Simula 67 OOP Pioneer

BEGIN
  OutText("Hello World");
  OutImage;
END

Zig 0.13 Modern Systems

const std = @import("std");
pub fn main() !void {
    std.debug.print("Hello World\n", .{});
}

Odin Game Systems

package main
import "core:fmt"
main :: proc() { fmt.println("Hello World") }

Hare Unix Systems

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

C3 C Evolution

import std::io;
fn void main() {
  io::printn("Hello World");
}

Nim 2 Metaprogramming

echo "Hello World"

V Vlang Simple

fn main() { println('Hello World') }

Carbon Google C++ Succ

fn Main() -> i32 {
  Print("Hello World");
  return 0;
}

Cppfront Cpp2 H. Sutter

main: () = {
  std::cout << "Hello World\n";
}

D 2.0 Modern Sys

import std.stdio;
void main() { writeln("Hello World"); }

Modula-3 DEC SRC

MODULE Hello EXPORTS Main;
IMPORT IO;
BEGIN
  IO.Put("Hello World\n");
END Hello.

Mesa Xerox PARC

Hello: PROGRAM =
BEGIN
  Put.Text["Hello World"];
END.

Limbo Inferno OS

implement Hello;
include "sys.m";
include "draw.m";

Hello: module {
  init: fn(nil: ref Draw->Context, nil: list of string);
};

init(nil: ref Draw->Context, nil: list of string) {
  sys := load Sys Sys->PATH;
  sys->print("Hello World\n");
}

Alef Plan 9

#include <alef.h>
void main(void) {
  print("Hello World\n");
}

Cyclone Safe C

#include <stdio.h>
int main() {
  printf("Hello World\n");
  return 0;
}

BitC Systems

(defun main () (print-string "Hello World\n"))

Myrddin Systems

use std
const main = {; std.put("Hello World\n") }

Austral Linear Types

module Hello is
  function main(): Unit is
    printLn("Hello World");
    return nil;
  end;
end module.

Vale Region Borrow

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

Lobster Game Lang

print "Hello World"

Pony Actor Model

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

Clay Systems Lang

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

Beef Game Systems

static void Main() {
  Console.WriteLine("Hello World");
}

Carp Lisp Systems

(defn main []
  (println "Hello World"))

Inko Ownership Safe

import std.stdio (STDOUT)

class async Main {
  fn async main {
    STDOUT.new.print("Hello World")
  }
}

C2 C Evolution

module hello;
import stdio;
fn i32 main() {
  stdio.puts("Hello World");
  return 0;
}

Cone 3D Systems

fn main():
  print "Hello World"

Jai Blow Game

#import "Basic";
main :: () {
  print("Hello World\n");
}

Odin ginger_bill

package main
import "core:fmt"
main :: proc() {
  fmt.println("Hello World")
}

Hare Drew DeVault

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

Scopes Systems Lisp

(print "Hello World")

Vala GNOME

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

Genie GNOME Alt

[indent=4]
init
    print "Hello World"

Terra Lua Low-level

local c = terralib.includec("stdio.h")
terra main()
  c.printf("Hello World\n")
end
main()

Virgil Lightweight Sys

def main() {
  System.puts("Hello World\n");
}

Muon LLVM Lang

fn main() void {
  @import("std").debug.print("Hello World\n");
}

Ceu Reactive Sys

output void PRINT;
emit PRINT => "Hello World";

Verona Microsoft

class Main {
  main() { Builtin.print("Hello World"); }
}

P Microsoft FSM

machine Hello {
  start state Init {
    entry { print("Hello World"); }
  }
}

Bosque Microsoft

namespace Main;
entrypoint function main(): String {
  return "Hello World";
}

Nelua Lua + C

print 'Hello World'

Wuffs Google Safe

// Hello World (safe codec lang)

SPARK Ada Verified Ada

with Ada.Text_IO;
procedure Hello is
begin
  Ada.Text_IO.Put_Line("Hello World");
end Hello;

Ravenscar Ada RT Profile

with Ada.Text_IO;
procedure Hello is
begin
  Ada.Text_IO.Put_Line("Hello World");
end Hello;

GNAT Ada FSF Compiler

with Ada.Text_IO;
procedure Hello is
begin
  Ada.Text_IO.Put_Line("Hello World");
end Hello;

FreePascal FPC Cross

program Hello;
begin
  WriteLn('Hello World');
end.

GNU Cobol GnuCOBOL

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
PROCEDURE DIVISION.
  DISPLAY "Hello World".
  STOP RUN.

Open Watcom C/C++

#include <stdio.h>
int main() {
  printf("Hello World\n");
  return 0;
}

LCC Lightweight C

#include <stdio.h>
int main() {
  printf("Hello World\n");
}

Langages web 0

Hello World pour le front-end et le back-end web.

HTML

<h1>Hello World</h1>

CSS

body::before {
  content: "Hello World";
}

JavaScript (navigateur)

console.log('Hello World');

TypeScript

const message: string = 'Hello World';
console.log(message);

PHP

<?php
echo "Hello World";
?>

Node.js

console.log('Hello World');

TSX (React)

export default function App() {
  return <h1>Hello World</h1>;
}

Vue SFC

<template>
  <h1>Hello World</h1>
</template>

Svelte

<h1>Hello World</h1>

Angular template

<h1>{{ title }}</h1>

title = 'Hello World';

SolidJS

const App = () => <h1>Hello World</h1>;

Astro

---
const title = 'Hello World';
---
<h1>{title}</h1>

ASP.NET Razor

<h1>Hello World</h1>

Pug

h1 Hello World

Handlebars

<h1>{{message}}</h1>

WebAssembly Text WAT

(module
  (import "console" "log" (func $log (param i32 i32)))
  ;; hello world via imported log + memory omitted for brevity
)

HTMX HTML + attributs

<button hx-get="/hello" hx-target="#out">Say Hello</button>
<div id="out">Hello World</div>

JSP

<% out.println("Hello World"); %>

CFML ColdFusion

<cfoutput>Hello World</cfoutput>

Blade Laravel

<h1>{{ 'Hello World' }}</h1>

Jinja2

<h1>{{ message }}</h1>

Twig Symfony

<h1>{{ message }}</h1>

Mako

<h1>${"Hello World"}</h1>

ERB Ruby on Rails

<h1><%= "Hello World" %></h1>

EJS Node.js

<h1><%= "Hello World" %></h1>

JSX React

const Hello = () => <h1>Hello World</h1>;
export default Hello;

Qwik

import { component$ } from '@builder.io/qwik';
export const App = component$(() => <h1>Hello World</h1>);

Lit Web Components

import { LitElement, html } from 'lit';
class HelloWorld extends LitElement {
  render() { return html`<h1>Hello World</h1>`; }
}
customElements.define('hello-world', HelloWorld);

Alpine.js

<div x-data="{ msg: 'Hello World' }" x-text="msg"></div>

Deno TypeScript runtime

console.log("Hello World");

Bun JS runtime

console.log("Hello World");

CoffeeScript

console.log 'Hello World'

LiveScript

console.log 'Hello World'

ClojureScript

(js/console.log "Hello World")

Haxe JS target

class Main {
  static function main() js.Browser.console.log("Hello World");
}

Scala.js

import scala.scalajs.js.Dynamic.global
global.console.log("Hello World")

GWT Google Web Toolkit

GWT.log("Hello World");

Kotlin/JS

fun main() {
  println("Hello World")
}

PHP 8.x short echo

<?= "Hello World" ?>

Ruby on Rails controller

class HelloController < ApplicationController
  def index
    render plain: "Hello World"
  end
end

Sinatra Ruby micro-framework

require 'sinatra'
get '/' do
  'Hello World'
end

Express.js Node.js

const express = require('express');
const app = express();
app.get('/', (req, res) => res.send('Hello World'));
app.listen(3000);

Fastify Node.js

import Fastify from 'fastify';
const app = Fastify();
app.get('/', async () => 'Hello World');
await app.listen({ port: 3000 });

Hono Edge runtime

import { Hono } from 'hono';
const app = new Hono();
app.get('/', (c) => c.text('Hello World'));
export default app;

Flask Python

from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello(): return 'Hello World'

FastAPI Python

from fastapi import FastAPI
app = FastAPI()
@app.get('/')
async def root(): return {'message': 'Hello World'}

Django view

from django.http import HttpResponse
def hello(request):
    return HttpResponse("Hello World")

Laravel route

Route::get('/', fn() => 'Hello World');

Gin Go framework

r := gin.Default()
r.GET("/", func(c *gin.Context) {
  c.String(200, "Hello World")
})
r.Run()

Fiber Go framework

app := fiber.New()
app.Get("/", func(c fiber.Ctx) error {
  return c.SendString("Hello World")
})
app.Listen(":3000")

Actix-web Rust

#[actix_web::main]
async fn main() -> std::io::Result<()> {
  HttpServer::new(|| {
    App::new().route("/", web::get().to(|| async { "Hello World" }))
  }).bind("0.0.0.0:8080")?.run().await
}

Axum Rust

use axum::{Router, routing::get};
#[tokio::main]
async fn main() {
  let app = Router::new().route("/", get(|| async { "Hello World" }));
  // bind + serve
}

Warp Rust

let hello = warp::path::end().map(|| "Hello World");
warp::serve(hello).run(([0,0,0,0], 3030)).await;

Phoenix Elixir

def index(conn, _params) do
  text conn, "Hello World"
end

Ktor Kotlin

fun Application.module() {
  routing {
    get("/") { call.respondText("Hello World") }
  }
}

Servant Haskell

type API = Get '[PlainText] String
server :: Server API
server = return "Hello World"

Yesod Haskell

getRootR :: Handler Html
getRootR = defaultLayout [whamlet|Hello World|]

Roc web

main = respond { status: 200, body: "Hello World" }

GraphQL SDL

type Query {
  hello: String
}

# resolver: () => "Hello World"

HAML

%h1 Hello World

Slim Ruby template

h1 Hello World

Nunjucks

<h1>{{ greeting }}</h1>

Mustache

<h1>{{greeting}}</h1>

Marko

<h1>Hello World</h1>

Ember.js Component

import Component from '@glimmer/component';
export default class Hello extends Component {
  get message() { return "Hello World"; }
}

Backbone.js View

var HelloView = Backbone.View.extend({
  render: function() {
    this.$el.html("Hello World");
    return this;
  }
});

Meteor Blaze template

<template name="hello">
  <h1>Hello World</h1>
</template>

Mithril.js

m.render(document.body, m("h1", "Hello World"))

Aurelia

export class App {
  message = 'Hello World';
}

Riot.js

<hello>
  <h1>{ message }</h1>
  <script>
    this.message = 'Hello World'
  </script>
</hello>

Alpine.js x-text

<div x-data="{ msg: 'Hello World' }">
  <h1 x-text="msg"></h1>
</div>

htmx

<button hx-get="/hello" hx-target="#result">
  Click Me
</button>
<div id="result"></div>
<!-- Server returns "Hello World" -->

Stimulus.js

import { Controller } from "@hotwired/stimulus"
export default class extends Controller {
  connect() { this.element.textContent = "Hello World" }
}

Stencil

import { Component, h } from '@stencil/core';
@Component({ tag: 'my-hello' })
export class MyHello {
  render() { return <h1>Hello World</h1>; }
}

SolidJS

import { render } from "solid-js/web";
const App = () => <h1>Hello World</h1>;
render(() => <App />, document.getElementById("app"));

Qwik

import { component$ } from '@builder.io/qwik';
export const App = component$(() => {
  return <h1>Hello World</h1>;
});

Nuxt.js Page

<template>
  <div>
    <h1>Hello World</h1>
  </div>
</template>

Next.js App Router

export default function Page() {
  return <h1>Hello World</h1>;
}

Remix Route

export default function Index() {
  return <h1>Hello World</h1>;
}

Astro Component

---
const msg = "Hello World";
---
<h1>{msg}</h1>

Svelte 5 Runes

<script>
  let msg = $state('Hello World');
</script>
<h1>{msg}</h1>

Lit Element

import {LitElement, html} from 'lit';
class HelloLit extends LitElement {
  render() { return html`<h1>Hello World</h1>`; }
}
customElements.define('hello-lit', HelloLit);

Imba

tag app-hello
  def render
    <self> <h1> "Hello World"
imba.mount <app-hello>

Gatsby .astro

import React from "react"
export default function Home() {
  return <h1>Hello World</h1>
}

Web Components Vanilla

class Hello extends HTMLElement {
  connectedCallback() {
    this.innerHTML = `<h1>Hello World</h1>`;
  }
}
customElements.define("hello-world", Hello);

ReasonML React

[@react.component]
let make = () => <h1> {React.string("Hello World")} </h1>;

Pug Jade template

h1 Hello World

Handlebars

<h1>{{title}}</h1>
<!-- context: { title: "Hello World" } -->

Liquid Shopify

<h1>{{ 'Hello World' }}</h1>

Smarty Template

<h1>{'Hello World'}</h1>

Jinja2 Python

<h1>{{ "Hello World" }}</h1>

Chirp Tornado

<h1>Hello World</h1>

LESS CSS preprocessor

@msg: "Hello World";
body::before { content: @msg; }

Sass / SCSS

$msg: "Hello World";
body::before { content: $msg; }

Stylus

@msg = "Hello World"
body::before
  content @msg

Pcss PostCSS

:root { --msg: "Hello World"; }
body::before { content: var(--msg); }

Twillio Liquid

{% assign msg = "Hello World" %}
{{ msg }}

VBScript ASP Classic

<% Response.Write("Hello World") %>

ColdFusion CFML Tag

<cfoutput>Hello World</cfoutput>

JSP JavaServer Pages

<% out.println("Hello World"); %>

GSP GroovyServer Pages

<%= "Hello World" %>

Blade Laravel

{{ 'Hello World' }}

Volt Phalcon CPU

{{ "Hello World" }}

Latte Nette

<h1>{"Hello World"}</h1>

Tornado Python Template

<h1>{{ "Hello World" }}</h1>

XSLT 2.0

<xsl:value-of select="'Hello World'"/>

SVG Text

<svg xmlns="http://www.w3.org/2000/svg">
  <text x="10" y="20">Hello World</text>
</svg>

Inertia.js SPA Bridge

<script setup>
defineProps({ message: String })
</script>
<template>{{ message }}</template>
// Controller: Inertia::render('Hello', ['message' => 'Hello World'])

Leptos Rust WASM

#[component]
fn App() -> impl IntoView {
    view! { <p>"Hello World"</p> }
}

Dioxus Rust UI

fn app() -> Element {
    rsx! { p { "Hello World" } }
}

Yew Rust WASM

use yew::prelude::*;
#[function_component]
fn App() -> Html {
    html! { <p>{"Hello World"}</p> }
}

Power Fx Microsoft

"Hello World"

Blazor C# WASM

@page "/hello"
<h1>@message</h1>
@code { string message = "Hello World"; }

HTMX Attribute

<div hx-get="/hello" hx-trigger="load">
  Hello World
</div>

LiveView Phoenix Elixir

defmodule HelloLive do
  use Phoenix.LiveView
  def render(assigns) do
    ~H"""<p>Hello World</p>"""
  end
end

Hotwire Turbo Frame

<turbo-frame id="hello">Hello World</turbo-frame>

Unpoly Server HTML

<a up-layer="new" href="/hello">Hello World</a>

Enhance Web Components

export default function Hello({ html }) {
  return html`<p>Hello World</p>`
}

Fresh Deno Framework

export default function Home() {
  return <p>Hello World</p>;
}

SolidStart Solid Meta

export default function Home() {
  return <main>Hello World</main>;
}

Analog Angular Meta

@Component({ template: '<p>Hello World</p>' })
export default class HelloPage {}

Hono Edge Server

import { Hono } from 'hono'
const app = new Hono()
app.get('/', c => c.text('Hello World'))

Elysia Bun Framework

import { Elysia } from 'elysia'
new Elysia()
  .get('/', () => 'Hello World')
  .listen(3000)

Vite Dev Server

<!DOCTYPE html>
<h1>Hello World</h1>
<script type="module" src="/main.js"></script>

Astro 4 Islands

---
// astro component
---
<h1>Hello World</h1>

11ty Eleventy SSG

---
title: Hello
---
Hello World

Hugo Go SSG

---
title: Hello
---
{{ .Title }} World

Zola Rust SSG

+++
title = "Hello"
+++
Hello World

Pelican Python SSG

Title: Hello
Hello World

Bridgetown Ruby SSG

---
title: Hello
---
Hello World

Wasp Full-stack DSL

app Hello {
  title: "Hello World"
}
route RootRoute { path: "/", to: MainPage }

RedwoodJS Full-stack

const HomePage = () => {
  return <h1>Hello World</h1>
}
export default HomePage

Blitz.js Next.js Fork

export default function Home() {
  return <h1>Hello World</h1>
}

T3 Stack tRPC + Next

export default function Home() {
  return <main>Hello World</main>
}

TanStack Start Router SSR

export const Route = createFileRoute('/')({ component: () => <p>Hello World</p> })

Bun Serve Runtime Server

Bun.serve({
  fetch() { return new Response("Hello World"); }
});

Deno Serve Runtime Server

Deno.serve(() => new Response("Hello World"));

WASM Component WIT Interface

// wit: export hello: func() -> string
fn hello() -> String { "Hello World".into() }

Cloudflare Worker Edge JS

export default {
  fetch() { return new Response("Hello World"); }
};

Vercel Edge Middleware

export const config = { runtime: 'edge' };
export default function() {
  return new Response('Hello World');
}

Netlify Edge Deno Functions

export default () => new Response("Hello World");

AWS Lambda Node.js

exports.handler = async () => ({
  statusCode: 200,
  body: 'Hello World'
});

Azure Function JS

module.exports = async function(context) {
  context.res = { body: "Hello World" };
};

GCP Cloud Function Python

def hello(request):
    return "Hello World"

Analog Angular Meta

export default defineComponent({
  template: `<p>Hello World</p>`
})

Nuxt 3 Vue SSR

<template><p>Hello World</p></template>

Next.js 14 App Router

export default function Page() {
  return <p>Hello World</p>;
}

Remix React Router

export default function Index() {
  return <p>Hello World</p>;
}

SvelteKit Svelte SSR

<p>Hello World</p>

Astro 4 Static + Islands

---
---
<p>Hello World</p>

Qwik Resumable

export const App = component$(() => {
  return <p>Hello World</p>;
});

Hono Edge Framework

import { Hono } from 'hono'
const app = new Hono()
app.get('/', (c) => c.text('Hello World'))
export default app

Elysia Bun Framework

import { Elysia } from 'elysia'
new Elysia()
  .get('/', () => 'Hello World')
  .listen(3000)

Htmx Hypermedia

<button hx-get="/hello" hx-swap="innerHTML">
  Click for Hello World
</button>

Leptos Rust Fullstack

#[component]
fn App() -> impl IntoView {
    view! { <p>"Hello World"</p> }
}

Dioxus Rust UI

fn app() -> Element {
    rsx! { p { "Hello World" } }
}

Yew Rust WASM

html! { <p>{ "Hello World" }</p> }

Blazor .NET WASM

<h1>Hello World</h1>
@code { }

Bolero F# Blazor

let view = text "Hello World"

Phoenix LiveView Elixir

def render(assigns) do
  ~H"""<p>Hello World</p>"""
end

Lucky Crystal Web

class Home::IndexPage < MainLayout
  def content
    text "Hello World"
  end
end

Mint SPA Language

component Main {
  fun render : Html {
    <p>"Hello World"</p>
  }
}

Marko eBay UI

<p>Hello World</p>

Riot.js Micro UI

<hello><p>Hello World</p></hello>

Mithril Hyperscript

m.render(document.body, m("p", "Hello World"))

Preact 3KB React

render(<p>Hello World</p>, document.body)

Inferno Fast UI

render(<p>Hello World</p>, document.body)

Stencil Ionic WC

@Component({ tag: 'hello' })
export class Hello {
  render() { return <p>Hello World</p>; }
}

Surplus S.js Compiler

const view = <p>Hello World</p>;

Crank.js Generator UI

function *Hello() { yield <p>Hello World</p>; }

Million.js Virtual DOM

block(() => <p>Hello World</p>)

Petite Vue Minimal Vue

<div v-scope>{{ 'Hello World' }}</div>
<script src="petite-vue.js" init></script>

Alpine.js Lightweight

<p x-data x-text="'Hello World'"></p>

Hyperapp Tiny VDOM

app({ view: () => h("p", {}, text("Hello World")) })

Zig Server HTTP

fn handler(response: *Response) !void {
    try response.writer().writeAll("Hello World");
}

FastAPI Python Web

from fastapi import FastAPI
app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello World"}

Gin Go Web

r := gin.Default()
r.GET("/", func(c *gin.Context) {
  c.String(200, "Hello World")
})
r.Run()

Fiber Go Express

app := fiber.New()
app.Get("/", func(c *fiber.Ctx) error {
  return c.SendString("Hello World")
})
app.Listen(":3000")

Actix Web Rust

async fn hello() -> impl Responder {
    "Hello World"
}

Axum Tokio Rust

async fn hello() -> &'static str {
    "Hello World"
}

Rocket Rust Web

#[get("/")]
fn hello() -> &'static str {
    "Hello World"
}

Warp Rust Filter

let hello = warp::path::end()
    .map(|| "Hello World");

Tide Async-std Rust

app.at("/").get(|_| async { Ok("Hello World") });

Poem Rust Web

#[handler]
async fn hello() -> &'static str {
    "Hello World"
}

Langages fonctionnels 0

Hello World en paradigme fonctionnel.

Haskell

main :: IO ()
main = putStrLn "Hello World"

F#

printfn "Hello World"

OCaml

print_endline "Hello World";;

Clojure

(println "Hello World")

Elixir

IO.puts("Hello World")

Erlang

-module(hello).
-export([start/0]).

start() ->
    io:format("Hello World~n").

Scheme

(display "Hello World")
(newline)

Racket

#lang racket
(displayln "Hello World")

Elm

main =
    text "Hello World"

PureScript

module Main where

import Prelude
import Effect.Console (log)

main = log "Hello World"

ReasonML

print_endline("Hello World");

Standard ML

print "Hello World\n";

Wolfram Language

Print["Hello World"]

Miranda

main = "Hello World"

Idris

main : IO ()
main = putStrLn "Hello World"

Agda

open import IO

main = putStrLn "Hello World"

Coq extraction OCaml

Require Import String.
Definition hello := "Hello World".

Hy Lisp pour Python

(print "Hello World")

Gleam

import gleam/io

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

LFE Lisp Flavored Erlang

(defun main ()
  (io:format "Hello World~n" '()))

Koka

fun main() {
  println("Hello World")
}

Mercury

:- module hello.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
main(!IO) :- io.write_string("Hello World\n", !IO).

Lean 4

def main : IO Unit :=
  IO.println "Hello World"

Raku Perl 6

say 'Hello World';

Factor

"Hello World" print

J array language

echo 'Hello World'

K Kdb+

`Hello World

Q kdb+/q

show "Hello World"

APL Dyalog

⎕←'Hello World'

BQN

"Hello World"

Uiua

&p "Hello World"

Arend

\func hello => "Hello World"

Haskell GHCi one-liner

putStrLn "Hello World"

Clean

module hello
import StdEnv
Start = "Hello World"

Curry

main :: IO ()
main = putStrLn "Hello World"

Felix

println "Hello World";

Frege Haskell on JVM

module Hello where
main = println "Hello World"

Bosque

Main::main(): String {
  return "Hello World";
}

Flix

def main(): Unit \ IO =
  println("Hello World")

Effekt

def main() = println("Hello World")

Granule

main : String
main = "Hello World"

Haskell Applicative

main = putStr =<< pure "Hello World"

Haskell do-notation

main :: IO ()
main = do
  let msg = "Hello World"
  putStrLn msg

OCaml Effect handlers 5.0

let () = print_endline "Hello World"

F# pipeline

"Hello World" |> printfn "%s"

Scala cats-effect

import cats.effect._
object Main extends IOApp.Simple {
  def run = IO.println("Hello World")
}

Clojure spec

(ns hello.core)
(defn -main [] (println "Hello World"))

Elixir pipe

"Hello World" |> IO.puts()

Erlang escript

#!/usr/bin/env escript
main(_) -> io:format("Hello World~n").

PureScript Node

module Main where
import Effect.Console (log)
main = log "Hello World"

Elm Browser

import Html exposing (text)
main = text "Hello World"

Idris 2

module Main
main : IO ()
main = putStrLn "Hello World"

Agda with IO

module Hello where
open import IO
main : Main
main = run (putStrLn "Hello World")

Isabelle/ML

ML {* writeln "Hello World" *}

Coq vernacular

Compute "Hello World".

Lean 4 tactics

#eval "Hello World"

Nix flake output

{ outputs = _: { hello = "Hello World"; }; }

Lisp LispWorks

(format t "Hello World~%")

Lisp SBCL

(progn (write-line "Hello World"))

Clojure ClojureCLR

(println "Hello World")

Scheme R7RS

(import (scheme base) (scheme write))
(display "Hello World") (newline)

Logo UCBLogo

print [Hello World]

Io functional style

"Hello World" print

Eta Haskell on JVM

main :: IO ()
main = putStrLn "Hello World"

YAP Prolog

:- write('Hello World'), nl.

GNU Prolog

:- initialization(main, main).
main :- write('Hello World'), nl.

Oz / Mozart

functor
import System
define
  {System.showInfo "Hello World"}
end

Alice ML

val () = print "Hello World\n"

Standard ML SML/NJ

print "Hello World\n";

Gleam Functional OTP

import gleam/io
pub fn main() {
  io.println("Hello World")
}

Racket

(print "Hello World")

Guile GNU

(display "Hello World\n")

Chicken Scheme

(print "Hello World")

Shen

(pr "Hello World~%")

Joy

(output "Hello World")

Kitten

"Hello World" say

ClojureScript

(js/console.log "Hello World")

LFE Lisp Flavored Erlang

(io:format "Hello World~n")

Hy

(print "Hello World")

Arc Lisp in Python

(prn "Hello World")

Erlang OTP

io:format("Hello World~n").

ReasonML

Js.log("Hello World");

ReScript

Js.log("Hello World")

FStar

printfn "Hello World"

Ur/Web

fun main () = return <xml><body>Hello World</body></xml>

ML

print "Hello World\n";

F# Script

printfn "Hello World"

OCaml Printf

Printf.printf "Hello World\n"

Haskell Polysemy

hello :: Member (Embed IO) r => Sem r ()
hello = embed $ putStrLn "Hello World"

TypeScript Effect-TS

import { Effect } from "effect"
const program = Effect.sync(() => console.log("Hello World"))
Effect.runSync(program)

Clean

module hello
import StdEnv
Start = "Hello World"

Miranda

main = [sys_message "Hello World\n"]

Curry

main = putStrLn "Hello World"

Flix

def main(): Unit \ IO = println("Hello World")

Hope

main = "Hello World\n"

SAC Single Assignment C

int main() {
  StdIO::print("Hello World\n");
  return 0;
}

Effekt

def main() = {
  println("Hello World")
}

Koka

fun main() {
  println("Hello World")
}

Unison Base

helloWorld : '{IO, Exception} ()
helloWorld _ = printLine "Hello World"

Roc cli

app "hello"
    packages { pf: "https://.." }
    imports [pf.Stdout]
    provides [main] to pf

main = Stdout.line "Hello World"

Nix Expression

x: "Hello World"

Verse Epic Games

hello_world := class:
    OnBegin<override>()<suspends>:void=
        Print("Hello World")

Murex

out "Hello World"

APL Dyalog

'Hello World'

J

'Hello World'

Pikchr Functional Graphics

text "Hello World"

Txl

print "Hello World";

Lustre

node main(true) returns (hello: bool);
let
  hello = true;
  -- Output externalisé
tel;

Lisp Emacs Lisp

(message "Hello World")

Erlang Elixir macro

defmodule Hello do
  defmacro say do
    quote do: IO.puts "Hello World"
  end
end

Mathematica Pure Func

Print["Hello World"] & []

SASL Turner 1976

hello = "Hello World"

KRC Turner 1981

hello = "Hello World"

Gofer Haskell Ancestor

main = putStr "Hello World\n"

Charity Category Theory

def hello : string = "Hello World".

Cayenne Dependent Types

hello :: String
hello = "Hello World"

Epigram Dependent Types

let hello : String
hello = "Hello World"

Lambda Prolog Logic + Lambda

type hello o.
hello :- print "Hello World\n".

Concurrent ML CML

fun main () = TextIO.print "Hello World\n"

FL Backus FP Succ.

/out "Hello World"

T Scheme Dialect

(display "Hello World")
(newline)

Twelf LF Meta-logic

hello : string = "Hello World".

Links Web Functional

fun main() {
  print("Hello World")
}

Koka Effect Types

fun main()
  println("Hello World")

Carp Lisp Systems

(defn main []
  (println "Hello World"))

Flix JVM Functional

def main(): Unit \ IO =
  println("Hello World")

Keli Functional

= "Hello World".display

Effekt Effect Handlers

def main() = println("Hello World")

Ante Low-level FP

print "Hello World"

Granule Graded Types

main : () 
main = toStdout "Hello World"

Dafny Verified

method Main() {
  print "Hello World\n";
}

Whiley Verified

import std::io
method main():
  io::println("Hello World")

Bosque Microsoft

namespace Main;
entrypoint function main(): String {
  return "Hello World";
}

Kitten Concatenative

"Hello World" say

Uiua Array Functional

&p "Hello World"

BQN APL Successor

•Out "Hello World"

Jakt Memory Safe

fn main() {
    println("Hello World")
}

Austral Linear Types FP

pragma Unsafe_Module;
import IO;
function main(): Unit is
  print("Hello World");
end;

Spiral ML + GPU

inl main () = console.write_ln "Hello World"

Verse Epic/Unreal FP

Hello():void=
  Print("Hello World")

Nix Functional Config

builtins.trace "Hello World" null

Shen Pattern FP

(define hello -> (output "Hello World~%"))

Joy Concatenative FP

"Hello World" putchars.

Cat Stack FP

"Hello World" write_line

Refal Pattern Match FP

$ENTRY Go { = <Prout 'Hello World'>; }

Io Prototype FP

"Hello World" println

Ioke JVM Prototype

"Hello World" println

Mercury Logic+Func

:- module hello.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
main(!IO) :- io.write_string("Hello World\n", !IO).

Oz Mozart Multi

{Browse 'Hello World'}

Q Kdb+ Vector

"Hello World"

K Array Functional

"Hello World"

APL Array Classic

'Hello World'

J Iverson Array

echo 'Hello World'

Erlang 27 Modern BEAM

-module(hello).
-export([main/0]).
main() -> io:format("Hello World~n").

Elixir 1.17 Modern FP

IO.puts("Hello World")

Haskell GHC2024 Modern

main = putStrLn "Hello World"

OCaml 5 Multicore

let () = print_endline "Hello World"

F# 8 .NET Modern

printfn "Hello World"

Elm 0.19 Web FP

main = text "Hello World"

PureScript Haskell for JS

module Main where
import Effect.Console
main = log "Hello World"

ReScript ML for JS

Js.log("Hello World")

Unison Content-addressed

main = '(printLine "Hello World")

Gleam BEAM Typed

import gleam/io
pub fn main() { io.println("Hello World") }

Roc Fast Functional

main =
  Stdout.line "Hello World"

Bend Parallel HVM

def main:
  return "Hello World"

Kind 2 Proof Lang

Main : IO Unit
Main = IO.print "Hello World"

Lean 4 Theorem Prover

def main : IO Unit :=
  IO.println "Hello World"

Verse Epic Games

hello_world : void =
  Print("Hello World")

Mojo Modular AI

fn main():
    print("Hello World")

Hylo Val Language

public fun main() {
  print("Hello World")
}

Ante Low-level FP

main () = print "Hello World"

Granule Linear Types

main : () <IO>
main = toStdout "Hello World"

Eff Algebraic Effects

let _ = print_string "Hello World"

Frank Effect Handlers

main! : [Console]Unit
main! = print "Hello World"

Fstar Proof-oriented

module Hello
open FStar.IO
let main () = print_string "Hello World\n"

ATS Applied Type System

implement main0 () =
  print "Hello World\n"

Mercury Logic-Functional

:- module hello.
:- pred main(io::di, io::uo) is det.
main(!IO) :-
  io.write_string("Hello World\n", !IO).

Curry Functional-Logic

main = putStrLn "Hello World"

Clean Uniqueness Types

module hello
import StdEnv
Start = "Hello World"

Idris 2 Dep Types

main : IO ()
main = putStrLn "Hello World"

Agda Proof FP

module Hello where
open import IO
main = putStrLn "Hello World"

Twelf Logic FP

hello : string = "Hello World".

Charity Category FP

def main = "Hello World"

Joy Concat FP

"Hello World" putchars.

Cat Stack FP

"Hello World" write

Kitten Concat Typed

"Hello World" say

Whiley Verified

import std::io
method main():
  io::println("Hello World")

Dafny Microsoft Verified

method Main() {
  print "Hello World\n";
}

Elm-UI Elm Layout

import Element exposing (text)
main = text "Hello World"

Dhall Functional Config

let msg = "Hello World" in msg

Nix Functional Pkg

builtins.trace "Hello World" null

Guile GNU Scheme

(display "Hello World")
(newline)

Chicken Scheme R7RS

(print "Hello World")

Gambit Scheme C

(display "Hello World")
(newline)

Chez Scheme R6RS Fast

(display "Hello World")
(newline)

Bigloo Scheme OPT

(module hello (main main))
(define (main argv)
  (print "Hello World"))

Larceny Scheme IEEE

(display "Hello World")
(newline)

Racket PLT Scheme

#lang racket
(displayln "Hello World")

Langages scripting 0

Hello World pour scripts, automation et shell.

Python

print("Hello World")

Perl

print "Hello World\n";

Lua

print("Hello World")

Tcl

puts "Hello World"

R

cat("Hello World\n")

awk

BEGIN { print "Hello World" }

sed

echo | sed 's/.*/Hello World/'

Groovy

println 'Hello World'

JScript Windows Script Host

WScript.Echo("Hello World");

VBScript Windows Script Host

WScript.Echo "Hello World"

Prolog

:- initialization(main).

main :-
    write('Hello World'), nl,
    halt.

AutoHotkey

MsgBox "Hello World"

Python 2.x

print "Hello World"

Python 3.x

print("Hello World")

Perl v5

say "Hello World";

Lua 5.x

io.write("Hello World\n")

Janet

(print "Hello World")

AppleScript

display dialog "Hello World"

REXX

say "Hello World"

GDScript Godot

func _ready():
    print("Hello World")

Expect

#!/usr/bin/expect -f
puts "Hello World"

Python Jython (JVM)

print "Hello World"

Python IronPython (.NET)

print "Hello World"

Ruby JRuby

puts 'Hello World'

Raku script

say "Hello World";

Tcl Tk widget

label .l -text "Hello World"
pack .l

Lua LuaJIT

print("Hello World")

mruby

puts 'Hello World'

CRuby Ruby 3.x

puts "Hello World"

PHP CLI script

<?php
echo "Hello World\n";

Groovy Groovysh

println 'Hello World'

Elixir IEx

IO.puts "Hello World"

Nix Nix expression

"Hello World"

Makefile

all:
	@echo "Hello World"

Xonsh

print("Hello World")

Ammonite Scala REPL

println("Hello World")

Matlab

disp('Hello World')

Octave

disp('Hello World')

Scilab

disp('Hello World')

Maxima

print("Hello World")$

SAS

data _null_;
  put 'Hello World';
run;

SPSS syntax

PRINT / 'Hello World'.
EXECUTE.

Stata

display "Hello World"

Smalltalk GNU Smalltalk

Transcript showCr: 'Hello World'.

Julia REPL

println("Hello World")

LabVIEW textual equiv

// Câbler un constante "Hello World" sur un nœud "Simple Error Handler"

AutoIt

MsgBox(0, "Hello", "Hello World")

Guile Scheme

(display "Hello World") (newline)

Chicken Scheme

(print "Hello World")

Chez Scheme

(display "Hello World") (newline)

Gambit Scheme

(display "Hello World\n")

CLIPS

(defrule hello
  =>
  (printout t "Hello World" crlf))

NewLISP

(println "Hello World")

picoLisp

(prinl "Hello World")

Arc Paul Graham

(prn "Hello World")

Babashka Clojure scripting

(println "Hello World")

Nim JavaScript target

echo "Hello World"

Crystal script

puts "Hello World"

Scala Scala 3 main

@main def hello() = println("Hello World")

Kotlin Script (.kts)

println("Hello World")

Swift Playground

import Foundation
print("Hello World")

Dart Script

void main() => print('Hello World');

Coffeescript Literate

    console.log 'Hello World'

Starlark Bazel build

print("Hello World")

Pkl Apple config

greeting = "Hello World"

HCL Terraform

output "hello" {
  value = "Hello World"
}

Jsonnet

{ greeting: "Hello World" }

Dhall

"Hello World"

Cue

greeting: "Hello World"

Nickel

{ greeting = "Hello World" }

M4 macro processor

Hello World

CMake script mode

message("Hello World")

Awk gawk

BEGIN { print "Hello World" }

Ruby one-liner

ruby -e 'puts "Hello World"'

Python one-liner

python -c 'print("Hello World")'

Perl one-liner

perl -e 'print "Hello World\n"'

Node.js one-liner

node -e 'console.log("Hello World")'

PHP one-liner

php -r 'echo "Hello World\n";'

Groovy one-liner

groovy -e 'println "Hello World"'

Scala one-liner

scala -e 'println("Hello World")'

Wolfram Script

wolframscript -code 'Print["Hello World"]'

Julia one-liner

julia -e 'println("Hello World")'

Deno eval

deno eval 'console.log("Hello World")'

Bun eval

bun -e 'console.log("Hello World")'

Fennel Lisp on Lua

(print "Hello World")

Squirrel

print("Hello World")

MoonScript

print "Hello World"

AngelScript

void main() {
  Print("Hello World\n");
}

ChaiScript

print("Hello World");

Wren script

System.print("Hello World")

MicroPython

print("Hello World")

CircuitPython

print("Hello World")

MicroLua

print("Hello World")

Haskell Cabal script

#!/usr/bin/env cabal
-- cabal-version: 3.0
main = putStrLn "Hello World"

CRuby Bundler inline

require 'bundler/inline'
gemfile {}
puts "Hello World"

Tcl namespace

namespace eval Hello {
  proc greet {} { puts "Hello World" }
}
Hello::greet

Chapel parallel

coforall i in 1..1 do writeln("Hello World");

X10

class Hello {
  public static def main(Rail[String]) {
    Console.OUT.println("Hello World");
  }
}

Fortress

component Hello
export Executable
run() = println "Hello World"
end

E language

println("Hello World")

Io coroutine

coro := Coroutine clone
coro setRunMessage("Hello World" println)
coro run

XSLT 1.0

<xsl:stylesheet version="1.0" xmlns:xsl="..">
  <xsl:template match="/">
    <xsl:text>Hello World</xsl:text>
  </xsl:template>
</xsl:stylesheet>

XQUERY

"Hello World"

VimScript

echo "Hello World"

Lua Neovim API

vim.notify("Hello World")

Emacs Lisp

(message "Hello World")

gs PostScript

(Hello World) = flush

Ghostscript

/Helvetica findfont 12 scalefont setfont
100 700 moveto
(Hello World) show
showpage

Inform 7

To begin: say "Hello World."

Twine Harlowe

Hello World

Godot GDScript 4.x

func _ready() -> void:
    print("Hello World")

Lua LÖVE 2D

function love.draw()
  love.graphics.print("Hello World", 0, 0)
end

Python Pygame

import pygame
pygame.init()
screen = pygame.display.set_mode((640, 480))
font = pygame.font.SysFont(None, 48)
screen.blit(font.render("Hello World", True, (255,255,255)), (0,0))
pygame.display.flip()

HaxeFlixel

class PlayState extends FlxState {
  override function create() {
    add(new FlxText(0, 0, 0, "Hello World"));
  }
}

Befunge-98

"dlroW olleH",,,,,,,,,,,@

Unlambda

`r```````````.H.e.l.l.o. .W.o.r.l.di

Freebasic

Print "Hello World"
Sleep

SmallBASIC

PRINT "Hello World"

PureBasic

OpenConsole()
PrintN("Hello World")
CloseConsole()

BlitzBasic

Print "Hello World"
WaitKey

Monkey X

Function Main()
  Print "Hello World"
End Function

QB64

PRINT "Hello World"
END

BBC BASIC for SDL

PRINT "Hello World"

Mawk / Nawk

BEGIN { print "Hello World" }

Expect

puts "Hello World"

Plop / Plop.js

module.exports = function (plop) {
  console.log("Hello World");
};

Deno Tasks

{
  "tasks": { "hello": "echo Hello World" }
}

Pkl Apple config

res = "Hello World"

Nickel Config lang

let msg = "Hello World" in msg

CUE

msg: "Hello World"

Dhall

"Hello World"

Jsonnet

{ msg: "Hello World" }

YAML / YQ pipeline

yq eval '{"msg": "Hello World"}' --null-input

JQ

jq -n '"Hello World"'

HCL HashiCorp

output "hello" {
  value = "Hello World"
}

Just Command runner

hello:
  @echo "Hello World"

Taskfile Task runner

tasks:
  hello:
    cmds:
      - echo "Hello World"

Ant Apache

<project default="hello">
  <target name="hello">
    <echo message="Hello World"/>
  </target>
</project>

Maven Apache

<project>
  <build>
    <plugins>
      <plugin>...</plugin>
      <!-- Echo Hello World plugin config -->
    </plugins>
  </build>
</project>

Gradle AntRun

task hello {
  doLast {
    ant.echo(message: "Hello World")
  }
}

Rake Ruby Make

task :hello do
  puts "Hello World"
end

Jake JS Make

desc('Say hello');
task('hello', function () {
  console.log('Hello World');
});

Nimble Nim build

task hello, "Say Hello":
  echo "Hello World"

Mix Elixir build

defmodule Mix.Tasks.Hello do
  use Mix.Task
  def run(_) do
    IO.puts("Hello World")
  end
end

Rebar3 Erlang build

%% In rebar config or script
io:format("Hello World~n").

Ansible Debug module

- hosts: localhost
  tasks:
    - name: Say Hello
      ansible.builtin.debug:
        msg: "Hello World"

Puppet Notify

notify { 'Hello World': }

Chef Notify

log 'Hello World'

SaltStack

hello_world:
  cmd.run:
    - name: echo "Hello World"

Vagrant Shell inline

Vagrant.configure("2") do |config|
  config.vm.provision "shell", inline: "echo Hello World"
end

Docker Dockerfile

FROM alpine
CMD ["echo", "Hello World"]

Docker Compose

services:
  hello:
    image: alpine
    command: echo "Hello World"

Kubernetes Job YAML

apiVersion: batch/v1
kind: Job
metadata:
  name: hello
spec:
  template:
    spec:
      containers:
      - name: hello
        image: alpine
        command: ["echo", "Hello World"]
      restartPolicy: Never

Helm Template

{{- print "Hello World" -}}

Github Actions

jobs:
  hello:
    runs-on: ubuntu-latest
    steps:
      - run: echo "Hello World"

GitLab CI

hello_job:
  script:
    - echo "Hello World"

Bitbucket Pipelines

hello_world:
  script:
    - echo "Hello World"

Jenkins CLI

pipeline {
  agent any
  stages {
    stage('Hello') {
      steps { echo 'Hello World' }
    }
  }
}

CircleCI

jobs:
  build:
    docker:
      - image: alpine
    steps:
      - run: echo "Hello World"

Travis CI

script:
  - echo "Hello World"

Prometheus PromQL hack

vector(1) * 0 + 1 # returns 1, conceptual hello

Logstash Log output

input { generator { count => 1 message => "Hello World" } }
output { stdout {} }

Vim Command Mode

:echo "Hello World"

Ed Line Editor

a
Hello World
.
1p

Nano / Pico

Hello World
[Ctrl-O pour sauver]

AWK One-liner cli

awk 'BEGIN{print "Hello World"}'

Perl CGI Script

#!/usr/bin/perl
print "Content-type: text/plain\n\n";
print "Hello World\n";

AppleScript

display dialog "Hello World"

HyperTalk HyperCard

put "Hello World" into message box

MacRuby

framework 'Foundation'
NSLog("Hello World")

JXA Mac OS X

app = Application.currentApplication()
app.includeStandardAdditions = true
app.displayAlert("Hello World")

AutoHotkey

MsgBox, Hello World

KiXtart

? "Hello World"
Sleep 2

Winbatch

? "Hello World"

WScript Windows Script Host

WScript.Echo("Hello World")

VBScript MsgBox

MsgBox "Hello World"

HTA HTML Application

<hta:application>
<script>alert('Hello World')</script>

SikuliX Visual Script

popup("Hello World")

Robot Framework

*** Test Cases ***
Say Hello
    Log To Console    Hello World

AutoLISP AutoCAD

(princ "Hello World")

MEL Maya Embedded Language

print("Hello World\n");

VEX Houdini 3D

printf("Hello World\n");

UnrealScript Maya/Unreal

print "Hello World\n";

Papyrus Bethesda (Skyrim)

Debug.Notification("Hello World")

GML GameMaker Language

show_message("Hello World");

QuakeC

ClientPrint(self, "Hello World");

ZZT-OOP Sweeney 1991

@Hello World

SourcePawn

PrintToServer("Hello World");

GSC Garry's Mod

show_debug_message("Hello World");

NQC Not Quite C (Lego)

task main() {
  TextOut(0, LCD_LINE1, "Hello World");
}

RobotC Mindstorms

task main() {
  displayString(1, "Hello World");
}

Karel Fanuc Robots

PROGRAM hello
BEGIN
  WRITE('Hello World', CR)
END hello

RAPID Fanuc

MODULE MainModule
  PROC main()
    TPWrite "Hello World";
  ENDPROC
ENDMODULE

G-Code CNC CNC

(MSG, Hello World)

Scratch Block visual

[Quand (Drapeau) cliqué]
[Dire (Hello World) pendant (2) secondes]

Snap!

[Dire (Hello World)]

App Inventor

[Notifier1.ShowAlert (Hello World!)]

Stencyl

[say (Hello World)]

Blockly

[call Notifier1.ShowAlert notice "Hello World"]

RPG Maker Drag and Drop

[Show Text: "Hello World"]

Construct 3 Event Sheet

System | On start of layout | Browser: Log "Hello World"

Unreal Blueprints Visual node

Event BeginPlay --> Print String (InString="Hello World")

Max/MSP Visual Audio

[message: "Hello World"] --> [print]

Pure Data pd

[msg "Hello World"(
|
[print]

TouchDesigner Text DAT

print("Hello World")

vvvv

[IOBox (String)] <- "Hello World"

Node-RED

[Inject] --(msg.payload="Hello World")--> [Debug]

IFTTT

If Button widget pressed
Then Send a notification: "Hello World"

Zapier

Action 1: Trigger
Action 2: Format Data (Text) -> "Hello World"

N8N

[Inject Node] --("Hello World")--> [Debug Node]

Bicep Azure Resource

param msg string = 'Hello World'
output greeting string = msg

ARM Template

{
  "$schema": "https:schema...",
  "outputs": {
    "greeting": {"type": "string", "value": "Hello World"}
  }
}

CloudFormation

"Outputs": {
  "Hello": { "Value": "Hello World" }
}

T-SQL SQL Server

PRINT 'Hello World';

PL/pgSQL PostgreSQL

DO $$ 
BEGIN 
  RAISE NOTICE 'Hello World'; 
END $$;

PL/SQL Oracle

BEGIN
  DBMS_OUTPUT.PUT_LINE('Hello World');
END;

Cypher Neo4j

RETURN "Hello World" AS message;

SPARQL RDF Query

SELECT ?greeting WHERE {
  BIND("Hello World" AS ?greeting)
}

Gremlin Graph Query

g.inject("Hello World")

KQL Kusto Query Language

print "Hello World"

SPL Splunk

| makeresults | eval message="Hello World"

DAX Power BI

EVALUATE { "Hello World" }

Power Query M

let
    Source = "Hello World"
in
    Source

MDX Analysis Services

WITH MEMBER [Measures].[Greeting] AS 'Hello World'
SELECT [Measures].[Greeting] ON 0 FROM [Model]

VHDL Hardware

entity hello_world is end;
architecture behavior of hello_world is
begin
  process begin
    report "Hello World";
    wait;
  end process;
end behavior;

Verilog Hardware

module main;
  initial begin
    $display("Hello World");
  end
endmodule

SystemVerilog

module main;
  initial begin
    $display("Hello World");
  end
endmodule

OpenSCAD 3D Modeling

echo("Hello World");

TLA+ Formal Spec

MODULE HelloWorld
EXTENDS TLC
ASSUME PrintT("Hello World")
====

Alloy Formal Spec

sig Greeting {}
-- Hello World is conceptual in Alloy

Promela Spin Model Checker

init {
  printf("Hello World\n")
}

Z Notation

Hello \defs "Hello World"

Q# Quantum

operation Main() : Unit {
    Message("Hello World");
}

Silq Quantum

def main() {
  print("Hello World");
}

Ren'Py Visual Novel

label start:
    "Hello World"
    return

ChoiceScript Interactive Fiction

Hello World
*finish

Ink Inkle

Hello World
-> DONE

ZIL Zork Indent

<ROUTINE GO ()
  <TELL "Hello World" CR>>

Gherkin Cucumber

Feature: Hello
  Scenario: Say Hello
    Given the message is HelloWorld
    Then it should output "Hello World"

GNU Make Makefile

all:
	@echo "Hello World"

Ninja Build System

rule echo
  command = echo Hello World
build all: echo

SCons

print('Hello World')

QMake

message("Hello World")

Lex / Flex

%%
.* { printf("Hello World\n"); }
%%
int main() { yylex(); return 0; }

Yacc / Bison

%{
#include <stdio.h>
%}
%%
hello: { printf("Hello World\n"); }
%%

JCL z/OS Mainframe

//HELLO JOB
//EXEC PGM=IEBGENER
//SYSPRINT DD SYSOUT=*
//SYSIN DD DUMMY
//SYSUT2 DD SYSOUT=*
//SYSUT1 DD *
Hello World
/*

Inform 6 Interactive Fiction

[ Main;
  print "Hello World^";
];

Lingo Macromedia Director

put "Hello World"

LotusScript IBM Notes

Sub Initialize
  Msgbox "Hello World"
End Sub

NetLogo

to setup
  print "Hello World"
end

SuperCollider

"Hello World".postln;

ChucK Music Language

<<< "Hello World" >>>;

Csound Audio

<CsoundSynthesizer>
<CsInstruments>
instr 1
  prints "Hello World\n"
endin
</CsInstruments>
</CsoundSynthesizer>

Sonic Pi Live Coding

print "Hello World"

Faust Audio DSP

// Signal pas de texte pure, mais convention:
process = 0; // "Hello World" of DSP

Overtone Clojure Audio

(println "Hello World")

LilyPond Music Engraving

\markup { "Hello World" }

TidalCycles Live Coding

putStrLn "Hello World"

Maxima

print("Hello World")$

Maple Math

printf("Hello World\n");

IDL Interactive Data

print, 'Hello World'

GAMS

display "Hello World" ;

AMPL

print "Hello World";

Etoys Squeak

Transcript show: 'Hello World'

Pico-8 Fantasy Console

print("Hello World")

TIC-80

trace("Hello World")

YARA Malware Rules

rule HelloWorld {
  strings: $a = "Hello World"
  condition: $a
}

Snort IDS Rules

alert tcp any any -> any any (msg:"Hello World";)

Zeek Network Monitor

event zeek_init() {
  print "Hello World";
}

DTrace

BEGIN {
  trace("Hello World");
  exit(0);
}

ActionScript 1.0 Flash 4

trace("Hello World");

Solidity Ethereum

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract HelloWorld {
  function hello() public pure returns (string memory) {
    return "Hello World";
  }
}

Vyper Ethereum

@external
@view
def hello() -> String[11]:
    return "Hello World"

Move Sui / Aptos

module hello::hello {
  use std::debug;
  public entry fun say_hello() {
    debug::print(&b"Hello World");
  }
}

Cadence Flow Blockchain

access(all) fun main(): String {
  return "Hello World"
}

Michelson Tezos

parameter unit;
storage string;
code { DROP; PUSH string "Hello World"; NIL operation; PAIR }

Cairo StarkNet

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

Noir Aztec ZK

fn main() {
    std::println("Hello World");
}

Sophia Aeternity

contract HelloWorld =
  entrypoint hello() = "Hello World"

Ballerina WSO2

import ballerina/io;
public function main() {
    io:println("Hello World");
}

Modelica

model HelloWorld
  annotation(experiment(StopTime=0));
equation
  Modelica.Utilities.Streams.print("Hello World");
end HelloWorld;

Stan Probabilistic

generated quantities {
  print("Hello World");
}

BUGS / JAGS Bayesian

model {
  # Hello World: probabilistic model placeholder
  x ~ dnorm(0, 1)
}

Esterel Synchrone

module HelloWorld:
  output O;
  emit O
end module

SIGNAL Synchrone

process hello = (? integer x ! integer y)
(| y := x |)
where integer x init 0
end;

CLU Liskov 1975

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

Structured Text PLC IEC 61131

PROGRAM HelloWorld
VAR
  msg : STRING := 'Hello World';
END_VAR
END_PROGRAM

Ladder Logic PLC

|---[ ]---[MOV 'Hello World' -> D100]---|

Instruction List PLC IL

LD 'Hello World'
ST msg

mIRC Script

alias hello {
  echo -a Hello World
}

LiveCode HyperCard succ.

on mouseUp
  answer "Hello World"
end mouseUp

Progress OpenEdge ABL

MESSAGE "Hello World" VIEW-AS ALERT-BOX.

Natural Software AG

WRITE 'Hello World'
END

bc Calculator

"Hello World\n"

dc Desk Calculator

[Hello World]p

Meson Build System

project('hello', 'c')
message('Hello World')

SYCL Khronos

#include <sycl/sycl.hpp>
int main() {
  sycl::queue q;
  q.submit([&](sycl::handler& h) {
    sycl::stream out(1024, 256, h);
    h.single_task([=]() { out << "Hello World"; });
  });
}

AssemblyScript WASM

export function hello(): string {
  return "Hello World";
}

MoonBit

fn main {
  println("Hello World")
}

Mint Web Lang

component Main {
  fun render : Html {
    <div>"Hello World"</div>
  }
}

Picat

main =>
  println("Hello World").

Hoon Urbit

(helm-hi "Hello World")

Dafny Microsoft

method Main() {
  print "Hello World\n";
}

Frink

println["Hello World"]

Pyret Éducatif

print("Hello World")

Wenyan 文言 (Chinois classique)

吾有一言。曰「「Hello World」」。書之。

Ezhil எழில் (Tamoul)

பதிப்பி "Hello World"

Rapira Soviétique 1970s

ПРОЦ СТАРТ()
  ВЫВОД: "Hello World"
КОН ПРОЦ

TECO Text Editor

FTHello World$

Datalog

greeting("Hello World").

miniKanren

(run* (q) (== q "Hello World"))

Toit IoT

main:
  print "Hello World"

Whiley

import std::io
method main(System.Console console):
    console.out.println("Hello World")

Carp Lisp + Systems

(defn main []
  (println "Hello World"))

Gravity

func main() {
  System.print("Hello World");
}

Wing Winglang Cloud

bring cloud;
log("Hello World");

Dark Darklang

"Hello World"

P4 Network Prog.

// P4 n'affiche pas de texte,
// mais header-field "Hello World" conceptuel

Halide Image Processing

// Halide est un DSL pour pipelines image
// Pas d'I/O texte native, conceptuel

Orc Concurrent

Println("Hello World")

Lox Crafting Interpreters

print "Hello World";

NetLogo ABM

to setup
  print "Hello World"
end

Kodu Xbox Edu

[When: see apple] [Do: say "Hello World"]

Etoys Squeak Edu

Transcript show: 'Hello World'

Rhai Rust Scripting

print("Hello World");

Deno TypeScript Runtime

console.log("Hello World"); // Deno

Bun JS Runtime

console.log("Hello World"); // Bun

Pkl Apple Config

message = "Hello World"

Jsonnet Config

{ message: "Hello World" }

CUE Config

message: "Hello World"

Dhall Config

{ message = "Hello World" }

Starlark Bazel

print("Hello World")

Nickel Config

{ message = "Hello World" }

KCL Config Lang

message = "Hello World"

Mojo Modular AI

fn main():
    print("Hello World")

Vale Systems

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

Austral Linear Types

module Hello is
  function main(): Unit is
    print("Hello World");
    return nil;
  end;
end module.

Hylo Val/Swift-like

public fun main() {
  print("Hello World")
}

Grain WebAssembly

print("Hello World")

Gleam BEAM/Erlang

import gleam/io
pub fn main() { io.println("Hello World") }

Roc Functional

main = Stdout.line "Hello World"

Bend Parallel HVM

def main():
  return "Hello World"

MOO MUD OO

@program hello:say
player:tell("Hello World");
.

MUSH TinyMUSH

@pemit me=Hello World

Inform 6 Z-machine

[ Main;
  print "Hello World^";
];

ChoiceScript CYOA

*comment Hello World game
Hello World!
*finish

Ink Inkle Narrative

Hello World
-> END

Yarn Spinner Unity Dialog

title: Start
---
Hello World
===

Fennel Lua Lisp

(print "Hello World")

Teal Typed Lua

local msg: string = "Hello World"
print(msg)

Wren Scripting

System.print("Hello World")

Janet Lisp/C Hybrid

(print "Hello World")

Squirrel Game Script

print("Hello World\n");

ChaiScript C++ Embed

print("Hello World")

AngelScript Game Embed

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

GDScript 2 Godot 4

@onready var label := $Label
func _ready():
  label.text = "Hello World"

MicroLua DS Homebrew

screen.print(SCREEN_UP, 0, 0, "Hello World")

Haxe Cross-compile

class Main {
  static function main() trace("Hello World");
}

Red Full-stack

Red [Title: "Hello"]
print "Hello World"

Rebol Messaging

REBOL []
print "Hello World"

Pike Swedish C-like

int main() {
  write("Hello World\n");
  return 0;
}

Boo .NET Python-like

print "Hello World"

Cobra .NET Python-like

class Hello
  def main
    print 'Hello World'

Fantom JVM/.NET

class Hello {
  static Void main() { echo("Hello World") }
}

Gosu JVM Scripting

print("Hello World")

Xtend Java Sugar

class Hello {
  def static void main(String[] args) {
    println("Hello World")
  }
}

Mirah JVM Ruby-like

puts "Hello World"

Just Command Runner

hello:
  echo "Hello World"

Taskfile Task Runner

tasks:
  hello:
    cmds:
      - echo "Hello World"

jq JSON Processor

"Hello World"

Dhall Config Language

"Hello World"

Jsonnet Data Templating

{ message: "Hello World" }

CUE Config Unify Execute

message: "Hello World"

Pkl Apple Config

message = "Hello World"

Babashka Clojure Script

(println "Hello World")

Fennel Lua Lisp

(print "Hello World")

Janet Lisp Embeddable

(print "Hello World")

Wren Small Fast

System.print("Hello World")

Gravity Swift-like Script

func main() {
  System.print("Hello World")
}

ChaiScript C++ Embed

print("Hello World")

Squirrel Game Script

print("Hello World")

AngelScript Game Engine

void main() {
  Print("Hello World");
}

Haxe Script Interpret Mode

trace("Hello World");

Koi Tiny Script

print("Hello World")

Arturo Readable Script

print "Hello World"

Raku Perl 6 Modern

say "Hello World";

Picolisp Minimal Lisp

(prinl "Hello World")

Rebol Messaging

print "Hello World"

Red Rebol Successor

print "Hello World"

Io Prototype Script

"Hello World" println

Factor Concatenative

"Hello World" print

Forth Stack

." Hello World" CR

PostScript Adobe Stack

(Hello World) print

m4 Macro Processor

dnl Hello World
Hello World

sed Stream Editor

echo | sed 's/.*/Hello World/'

AWK Text Processing

BEGIN { print "Hello World" }

Expect Tcl Automation

send "Hello World\r"

AutoIt Windows Auto

MsgBox(0, "Greeting", "Hello World")

AHK v2 AutoHotkey

MsgBox "Hello World"

KiXtart Logon Script

? "Hello World"

VBScript Windows

WScript.Echo "Hello World"

JScript Windows

WScript.Echo("Hello World");

Boo .NET Script

print "Hello World"

Io Prototype OO

"Hello World" println

Squirrel Game Script

print("Hello World\n");

Pawn Embedded Script

main()
    printf("Hello World\n")

ChucK Audio Script

<<< "Hello World" >>>;

Cling C++ REPL

#include <iostream>
std::cout << "Hello World" << std::endl;

Nit Modular OO

print "Hello World"

Seed7 Extensible

$ include "seed7_05.s7i";
const proc: main is func
  begin
    writeln("Hello World");
  end func;

Vala Script GNOME

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

Zig Build System

const std = @import("std");
pub fn main() void {
    std.debug.print("Hello World\n", .{});
}

Langages shell 0

Interpréteurs de commandes, shells Unix/Linux/Windows et shells modernes.

Bourne Shell sh (1977)

#!/bin/sh
echo "Hello World"

Bash Bourne Again Shell

#!/bin/bash
echo "Hello World"

Bash Here-string

cat <<< "Hello World"

Bash printf

printf '%s\n' "Hello World"

Bash $'...' ANSI-C

echo $'Hello World'

Zsh Z Shell

#!/bin/zsh
print "Hello World"

Zsh autoload function

autoload -Uz hello
hello() { echo "Hello World" }
hello

Fish Friendly Interactive Shell

echo "Hello World"

Ksh KornShell 93

#!/bin/ksh
print "Hello World"

Csh C Shell

#!/bin/csh
echo "Hello World"

Tcsh TENEX C Shell

#!/bin/tcsh
echo "Hello World"

Dash Debian Almquist Shell

#!/bin/dash
echo "Hello World"

Ash Almquist Shell

#!/bin/ash
echo "Hello World"

BusyBox sh Embedded Linux

#!/bin/busybox sh
echo "Hello World"

POSIX sh Portable Shell

#!/bin/sh
echo "Hello World"

Mksh MirBSD Korn Shell

#!/bin/mksh
print "Hello World"

Pdksh Public Domain Ksh

#!/bin/pdksh
echo "Hello World"

PowerShell 5.1 Windows

Write-Output "Hello World"

PowerShell 7+ Cross-platform

"Hello World"

PowerShell Write-Host couleur

Write-Host "Hello World" -ForegroundColor Green

Batch CMD.exe Windows

@echo off
echo Hello World

COMMAND.COM MS-DOS

ECHO Hello World

4DOS JP Software

@echo Hello World

Nushell Nu moderne

"Hello World"

Nushell Pipeline

"Hello World" | print

Oil Shell OSH compatible

echo "Hello World"

YSH Oil Shell moderne

echo "Hello World"

Elvish Shell moderne

echo "Hello World"

Xonsh Python + Shell

print("Hello World")

Murex DevOps Shell

out "Hello World"

Ion Redox OS Shell

echo Hello World

NGS Next Generation Shell

echo("Hello World")

Rash Racket Shell

#lang rash
echo Hello World

Amber Bash Transpiler

echo "Hello World"

Batsh Cross-platform Shell

println("Hello World");

Zx Google JS→Bash

await $`echo Hello World`;

Bun Shell Bun.sh

import { $ } from "bun";
await $`echo Hello World`;

RC Shell Plan 9

echo Hello World

Es Shell Extensible Shell

echo Hello World

Scsh Scheme Shell

(display "Hello World")
(newline)

Thompson Shell Unix V6 1971

echo Hello World

Hamilton C Shell Windows

echo Hello World

Wish Tcl/Tk Shell

puts "Hello World"

Tclsh Tcl Shell

puts "Hello World"

CLIST IBM TSO Shell

PROC 0
WRITE Hello World
END

REXX IBM Shell

say "Hello World"

JCL z/OS Job Shell

//HELLO  JOB
//STEP1  EXEC PGM=IEFBR14
//SYSOUT DD SYSOUT=*
/*  Hello World

NuttX NSH RTOS Shell

echo Hello World

BeanShell Java Shell

print("Hello World");

Oh Unix Shell

echo "Hello World"

Yash Yet Another Shell

echo "Hello World"

Hush Unix Shell

echo Hello World

Crush Typed Shell

echo "Hello World"

Langages scientifiques & probabilistes 0

Calcul numérique, statistiques, modélisation et langages probabilistes.

MATLAB

disp('Hello World')

GNU Octave

disp('Hello World')

Scilab

disp('Hello World')

R

cat("Hello World\n")

R print()

print("Hello World")

Mathematica Wolfram

Print["Hello World"]

Wolfram Language Functional

"Hello World" // Print

Maple

printf("Hello World\n");

Maxima

print("Hello World")$

SageMath

print("Hello World")

Julia

println("Hello World")

Julia macro

@info "Hello World"

IDL Interactive Data Language

print, 'Hello World'

Stan Probabiliste bayésien

generated quantities {
  print("Hello World");
}

BUGS Bayesian

model {
  # Hello World - modèle probabiliste
  x ~ dnorm(0, 1)
}

JAGS Bayesian MCMC

model {
  mu ~ dnorm(0, 0.001)
  # Bayesian Hello World
}

SPSS Syntax

ECHO 'Hello World'.

Stata

display "Hello World"

SAS

data _null_;
  put 'Hello World';
run;

GAMS Optimisation

display "Hello World";

AMPL Optimisation

print "Hello World";

GLPK MathProg

printf "Hello World\n";

Modelica

model HelloWorld
equation
  Modelica.Utilities.Streams.print("Hello World");
end HelloWorld;

Simulink Display Block

% Display block affichant 'Hello World'

NumPy Python

import numpy as np
a = np.array(list(b"Hello World"))
print(bytes(a).decode())

Pandas Python

import pandas as pd
df = pd.DataFrame({"msg": ["Hello World"]})
print(df.msg[0])

SymPy Python symbolique

from sympy import Symbol
x = Symbol('Hello World')
print(x)

Fortran 2018 Scientifique moderne

program hello
  print *, "Hello World"
end program hello

Futhark GPU Array

-- Futhark: pas d'I/O texte, array lang GPU
entry main = 42i32

Chapel HPC Parallel

writeln("Hello World");

X10 IBM HPC

public class Hello {
  public static def main(Rail[String]) {
    Console.OUT.println("Hello World");
  }
}

Frink Unités physiques

println["Hello World"]

Datalog Logique relationnelle

greeting("Hello World").

miniKanren Logique

(run* (q) (== q "Hello World"))

Prolog SWI scientifique

:- initialization(main).
main :- write('Hello World'), nl, halt.

Picat Logic + Scripting

main =>
  println("Hello World").

GAP Group Theory

Print("Hello World\n");

Magma Algebra System

print "Hello World";

PARI/GP Number Theory

print("Hello World")

Singular Algebra commutative

"Hello World";

Axiom / FriCAS

output("Hello World")

Reduce Computer Algebra

write "Hello World";

Cadabra Tensor Algebra

print("Hello World")

PyTorch Tensor

import torch
t = torch.tensor(list(b"Hello World"))
print(bytes(t.numpy().astype('uint8')).decode())

TensorFlow tf.print

import tensorflow as tf
tf.print("Hello World")

Keras Callback

import keras
print("Hello World")

JAX Google

import jax
print("Hello World")

Polars DataFrame

import polars as pl
df = pl.DataFrame({"msg": ["Hello World"]})
print(df["msg"][0])

DuckDB SQL analytique

SELECT 'Hello World';

ClickHouse OLAP

SELECT 'Hello World';

Wolfram Alpha Natural Input

"Hello World"

GNUplot

set label "Hello World" at 0,0
plot 0

Gnuplot Terminal

print "Hello World"

OpenModelica

model Hello
equation
  Modelica.Utilities.Streams.print("Hello World");
end Hello;

Dymola Modelica IDE

Modelica.Utilities.Streams.print("Hello World");

Comsol Script

disp('Hello World')

Fortran coarray parallel

program hello
  if (this_image() == 1) print *, "Hello World"
end program hello

HPF High Performance Fortran

PROGRAM hello
  PRINT *, 'Hello World'
END

MPI C Message Passing

#include <mpi.h>
#include <stdio.h>
int main(int argc, char** argv) {
  MPI_Init(&argc, &argv);
  printf("Hello World\n");
  MPI_Finalize();
}

OpenMP C parallel

#include <stdio.h>
#include <omp.h>
int main() {
  #pragma omp parallel
  printf("Hello World from thread %d\n", omp_get_thread_num());
}

Spark SQL

SELECT 'Hello World' AS greeting;

PySpark DataFrame

from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()
spark.sql("SELECT 'Hello World'").show()

Dask Parallel Python

import dask
print("Hello World")

LabTalk Origin

type "Hello World";

Igor Pro

print "Hello World"

ROOT CERN C++

void hello() {
  std::cout << "Hello World" << std::endl;
}

Chapel HPC Parallel

writeln("Hello World");

X10 HPC IBM

Console.OUT.println("Hello World");

Fortress Sun HPC

export Executable
run() = println("Hello World")

UPC Unified Parallel C

#include <upc.h>
#include <stdio.h>
int main() { printf("Hello World\n"); }

Futhark GPU Functional

-- Hello World (Futhark is array-oriented)
let main = [72, 101, 108, 108, 111]

Halide Image DSP

Func hello;
hello() = print("Hello World");
hello.realize();

SageMath Python Math

print("Hello World")  # SageMath session

Maxima CAS

print("Hello World")$

Cadabra 2 Tensor CAS

print("Hello World")

GeoGebra Script Math Edu

SetValue[text1, "Hello World"]

Desmos Graphing Calc

y = 0 \{0 < x < 1\}
\text{Hello World}

Coq Proof Assistant

Require Import String.
Definition hello := "Hello World"%string.

Lean 4 Theorem Prover

#eval IO.println "Hello World"

Isabelle HOL Prover

value "STR ''Hello World''"

Agda Dependently Typed

module Hello where
open import IO
main = run (putStrLn "Hello World")

Idris 2 Dependent Types

main : IO ()
main = putStrLn "Hello World"

F* Verified ML

module Hello
let main () = FStar.IO.print_string "Hello World\n"

Arend HoTT Prover

-- Arend has no IO; this is a type-level "Hello World"
\func hello => 0

Cubical Agda HoTT

{-# OPTIONS --cubical #-}
module Hello where
-- Type-level Hello World

Wolfram Language 14

Print["Hello World"]

Polars DataFrame DSL

import polars as pl
df = pl.DataFrame({"msg": ["Hello World"]})
print(df)

DuckDB SQL OLAP

SELECT 'Hello World';

SymPy Symbolic Python

from sympy import *
print("Hello World")

SageMath Math System

print("Hello World")

ROOT CERN C++

void hello() {
  std::cout << "Hello World" << std::endl;
}

Cadabra Physics CAS

print("Hello World")

Dex Differentiable

:p "Hello World"

Futhark GPU Functional

entry main : []u8 = "Hello World"

Ferret Scientific Clojure

(println "Hello World")

Coq Proof Assistant

Compute "Hello World".

Isabelle HOL Prover

value "STR ''Hello World''"

Alloy Model Checker

sig HelloWorld {}
run {} for 1

TLA+ Lamport Spec

---- MODULE Hello ----
Init == TRUE
\\ Hello World
====

Maude Rewriting Logic

mod HELLO is
  op hello : -> String .
  eq hello = "Hello World" .
endm

GAP Group Theory

Print("Hello World\n");

Singular Algebra CAS

"Hello World";

Pari/GP Number Theory

print("Hello World")

Axiom Computer Algebra

"Hello World" :: String

Macaulay2 Algebraic Geom

print "Hello World"

OpenModelica Modeling

model Hello
  annotation(experiment(StopTime=1));
equation
  Modelica.Utilities.Streams.print("Hello World");
end Hello;

Scilab Open MATLAB

disp("Hello World")

FreeMat MATLAB Clone

printf('Hello World\n')

Yorick Scientific Viz

write, "Hello World"

AMPL Math Programming

printf "Hello World\n";

GAMS Optimization

display "Hello World";

Pymol Molecular Viz

print("Hello World")

Gnuplot Plot Scripting

set title "Hello World"
plot sin(x)

GDL GNU Data Lang

print, 'Hello World'

Reduce Computer Algebra

write "Hello World";

Magma Number Theory

print "Hello World";

PCASTL Math Interpret

print("Hello World")

Euler Math IDE

>"Hello World"

Genius GNOME Math

print("Hello World")

Frink Unit-Aware

println["Hello World"]

Kaleidoscope LLVM Tutorial

# Hello World
def hello() printd(72);

Torch Lua ML

print('Hello World')

Theano Python GPU

import theano
print("Hello World")

Caffe Deep Learning

# Hello World - LeNet example
print("Hello World")

MLlib Spark ML

println("Hello World from MLlib")

H2O.ai AutoML

import h2o
h2o.init()
print("Hello World")

Weka Java ML

System.out.println("Hello World from Weka");

SPSS Syntax IBM Stats

TITLE 'Hello World'.
EXECUTE.

SAS Analytics

data _null_;
  put 'Hello World';
run;

Stata Statistics

display "Hello World"

Wolfram Mathematica Cloud

CloudDeploy["Hello World"]

Sage SageMath

print("Hello World")

ROOT CERN C++ REPL

std::cout << "Hello World" << std::endl;

Langages éducatifs & visuels 0

Langages conçus pour l'apprentissage, la programmation visuelle et les projets éducatifs.

Scratch MIT

[Quand (Drapeau vert) cliqué]
[Dire (Hello World) pendant (2) secondes]

Scratch Jr Tablette

[Appuyer drapeau vert] → [Say "Hello World"]

Snap! Berkeley

[Dire (Hello World)]

Blockly Google

[print "Hello World"]

App Inventor MIT Android

[call Notifier1.ShowAlert notice "Hello World"]

Thunkable

[Show Alert: "Hello World"]

Logo UCBLogo

print [Hello World]

Logo MSWLogo

MESSAGEBOX "Greet [Hello World]

NetLogo Agent-Based

to setup
  print "Hello World"
end

StarLogo

to setup
  user-message "Hello World"
end

Kodu Xbox Game Lab

[When: always] [Do: say "Hello World"]

Etoys Squeak

Transcript show: 'Hello World'

Alice Carnegie Mellon 3D

[say "Hello World"]

Greenfoot Java éducatif

System.out.println("Hello World");

BlueJ Java éducatif

public class Hello {
  void sayHello() {
    System.out.println("Hello World");
  }
}

Pyret Brown Univ.

print("Hello World")

Racket Éducatif

#lang racket
(displayln "Hello World")

Processing Graphique éducatif

void setup() {
  println("Hello World");
}

p5.js Processing JS

function setup() {
  createCanvas(400, 200);
  text("Hello World", 10, 100);
}

Karel Stanford CS106A

/* Karel ne peut pas afficher de texte,
   il pose des "beepers" en guise de Hello */

Stencyl Game Editor

[say (Hello World)]

Construct 3 Event Sheet

System | On start | Browser: Log "Hello World"

RPG Maker Drag and Drop

[Show Text: "Hello World"]

Unreal Blueprints Visual Node

Event BeginPlay → Print String ("Hello World")

Godot Visual Script 3.x

[Output] → print("Hello World")

Twine Harlowe IF

:: Start
Hello World

Twine SugarCube

<<print "Hello World">>

Inform 7 Fiction Interactive

"Hello World" by Author.
The Lab is a room.
When play begins, say "Hello World."

ChoiceScript IF texte

Hello World
*finish

Ren'Py Visual Novel

label start:
    "Hello World"
    return

Ink Inkle Studios

Hello World
-> DONE

PICO-8 Fantasy Console

print("hello world")

TIC-80 Fantasy Console

trace("Hello World")

Wenyan 文言 (Chinois classique)

吾有一言。曰「「Hello World」」。書之。

Ezhil எழில் (Tamoul)

பதிப்பி "Hello World"

Rapira РАПИРА (Soviétique)

ПРОЦ СТАРТ()
  ВЫВОД: "Hello World"
КОН ПРОЦ

Robik РОБИК (Soviétique enfants)

НАПИСАТЬ "Hello World"

LiveCode HyperCard successeur

on mouseUp
  answer "Hello World"
end mouseUp

Small Basic Microsoft

TextWindow.WriteLine("Hello World")

BASIC-256 Éducatif

print "Hello World"

Sonic Pi Music Edu

puts "Hello World"

Greenfoot Java Edu

import greenfoot.*;
public class HelloWorld extends Actor {
    public void act() {
        System.out.println("Hello World");
    }
}

BlueJ Java Edu

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello World"); // BlueJ IDE
    }
}

Kodu Game Lab

WHEN [always] DO [say] ["Hello World"]

GameMaker GML

show_message("Hello World");

Twine Harlowe 3

:: Start
Hello World

Ren'Py Visual Novel

label start:
    "Hello World"

Inform 7 Interactive Fiction

"Hello" by Author.
The Lab is a room. "Hello World"

TADS 3 Interactive Fiction

#include <tads.h>
main(args) { "Hello World\n"; }

Quest IF Engine

msg ("Hello World")

AGS Adventure Game Studio

function room_AfterFadeIn() {
  Display("Hello World");
}

Raptor Flowchart

PUT "Hello World" TO Display

Flowgorithm Visual

Output "Hello World"

PSeInt Pseudocode ES

Proceso Hello
    Escribir "Hello World"
FinProceso

Visual Logic Flowchart

Output: "Hello World"

Blockly Text Export

window.alert('Hello World');

DrRacket Edu IDE

#lang racket
(displayln "Hello World")

WeScheme Browser Scheme

(printf "Hello World")

Pyret Bootstrap

print("Hello World")

Snap! BYOB Blocks

say [Hello World]

NetsBlox Networked Snap!

say [Hello World] for (2) secs

GP Blocks Visual

print 'Hello World'

StarLogo Nova Agent Sim

say "Hello World"

AgentSheets Simulation

IF true THEN say("Hello World")

Tynker Kids Coding

say "Hello World"

Swift Playgrounds iPad Edu

print("Hello World")

Hopscotch iPad Blocks

Set Text to "Hello World"

App Inventor MIT Blocks

[When Screen1.Initialize]
  [set Label1.Text to "Hello World"]

EduPython FR Edu IDE

print("Hello World")  # EduPython

RUR-PLE Robot Python

print("Hello World")  # Robot learns

RoboMind Robot Edu

paintWhite
forward(1)
# Hello World via robot movement

Guido van Robot GvR

move
turnleft
# Robot says Hello World

Karel++ C++ Karel

task {
  message("Hello World");
}

Little Man Computer LMC

LDA MSG
OUT
HLT
MSG DAT 072  ; H = Hello World

micro:bit Python MakeCode

from microbit import *
display.scroll("Hello World")

Calliope mini MakeCode

basic.showString("Hello World")

Arduino IDE Serial

void setup() {
  Serial.begin(9600);
  Serial.println("Hello World");
}
void loop() {}

mBlock mBot Blocks

[when green flag clicked]
[show "Hello World" on LED matrix]

VEXcode VEX Robotics

Brain.Screen.print("Hello World");

LEGO SPIKE Python

from spike import PrimeHub
hub = PrimeHub()
hub.light_matrix.write("Hello World")

CodeCombat Game Edu

hero.say("Hello World")

Replit Cloud IDE

print("Hello World")  # Replit Python

Thonny Beginner IDE

print("Hello World")  # Thonny IDE

Mu Editor Python Edu

print("Hello World")  # Mu Editor

Codey Rocky Makeblock

rocky.show("Hello World")

CoSpaces 3D Blocks

// CoBlock: [Display "Hello World"]

Pencil Code CoffeeScript Edu

write "Hello World"

Codecademy Python Track

print("Hello World")  # Codecademy

Khan Academy JS Draw

text("Hello World", 200, 200);

Codecollab Classroom

console.log("Hello World"); // Codecollab

Trinket.io Python Web

print("Hello World")  # trinket.io

p5.js Creative Edu

function setup() {
  createCanvas(400, 200);
}
function draw() {
  text("Hello World", 50, 100);
}

Processing Creative Edu

void setup() {
  size(400, 200);
}
void draw() {
  text("Hello World", 50, 100);
}

ScratchJr Ages 5-7

[Start] → [Say "Hello World"]

Dash Robot Wonder Workshop

dash.say("Hello World")

Kodable Kids Coding

say("Hello World")

Grasshopper Google Learn

print('Hello World')

Lightbot Puzzle Coding

// Séquence: LIGHT → HELLO WORLD

AppLab Code.org

console.log("Hello World");

Tynker Kids Platform

print("Hello World")

Micro:bit MakeCode BBC

basic.showString("Hello World")

Thunkable No-Code App

Label.Text = "Hello World"

Ozobot Color Codes

// Draw: Blue-Red-Green → Say "Hello World"

Sphero SPRK Robot Ball

async function startProgram() {
  speak("Hello World", true);
}

Cubetto Primo Toys

// Sequence: Forward → Say Hello World

Bee-Bot Floor Robot

// Program: FWD FWD → "Hello World"

Osmo Coding Tangible

// Drag blocks: SAY → "Hello World"

LEGO Mindstorms EV3 Block

// Display block → Text "Hello World"

VEX VR Robotics

brain.screen.print("Hello World")

mBlock Makeblock

display.show("Hello World")

Swift Playgrounds iPad

print("Hello World")

Mimo Learn Coding

print("Hello World")

Codecombat Game Learn

hero.say("Hello World")

Kodu Xbox Game Lab

WHEN [always] DO [say] ["Hello World"]

Greenfoot Java Visual

public void act() {
  System.out.println("Hello World");
}

BlueJ Java Edu

public class Hello {
  public void sayHello() {
    System.out.println("Hello World");
  }
}

Jeroo OOP Intro

method main() {
  Jeroo j = new Jeroo();
  j.say("Hello World");
}

Karel J Stanford CS106A

// Karel turns and says Hello World

RobotC VEX Edu

task main() {
  displayString(1, "Hello World");
}

EV3 MicroPython LEGO

from pybricks.tools import print
print("Hello World")

Finch Robot BirdBrain

finch.print("Hello World")

Hopscotch iPad Coding

set text to "Hello World"

Daisy Dino Ages 3+

SAY "Hello World"

Cargo-Bot iPad Puzzle

// Solve puzzle: HELLO WORLD

Robot Turtles Board Game+

// Cards: FWD → "Hello World"

primo.io Wooden Blocks

// Sequence: [Forward][Say] Hello World

Cozmo SDK Anki Robot

robot.say_text("Hello World").wait_for_completed()

RoboMind Edu Robot

write("Hello World")

Flowgorithm Flowchart IDE

Output "Hello World"

Raptor Flowchart Tool

PUT "Hello World" TO Display

PSeInt Pseudocode ES

Proceso Hello
  Escribir "Hello World"
FinProceso

Algébrique FR Pseudocode

Début
  Ecrire("Hello World")
Fin

Scratch 3 MIT 2019

[quand drapeau vert cliqué]
[dire [Hello World]]

Snap! Berkeley

(say [Hello World])

NetsBlox Vanderbilt

(say [Hello World])

GP Blocks Harc

say 'Hello World'

Pocket Code Catrobat

when [start]
say "Hello World" for 2 seconds

MIT App Inventor Android

when Screen1.Initialize
  set Label1.Text to "Hello World"

Turtle Art OLPC

[show "Hello World"]

Langages industriels & embarqué 0

Automates programmables (PLC), robotique, hardware description, GPU et systèmes embarqués.

Structured Text IEC 61131-3

PROGRAM HelloWorld
VAR
  msg : STRING := 'Hello World';
END_VAR
END_PROGRAM

Ladder Logic PLC Relais

|---[ ]---[MOV 'Hello World' → D100]---|

Instruction List IEC 61131 IL

LD 'Hello World'
ST msg

Function Block Diagram FBD

[CONST 'Hello World']─→[MOVE]─→[msg]

Sequential Function Chart SFC

Step1 → Action: msg := 'Hello World';

RAPID ABB Robots

MODULE MainModule
  PROC main()
    TPWrite "Hello World";
  ENDPROC
ENDMODULE

Karel Fanuc Robots

PROGRAM hello
BEGIN
  WRITE('Hello World', CR)
END hello

KRL KUKA Robots

DEF main()
  MsgNotify("Hello World")
END

URScript Universal Robots

textmsg("Hello World")

VAL3 Stäubli Robots

begin
  putln("Hello World")
end

G-Code CNC

(MSG, Hello World)

NQC LEGO Mindstorms RCX

task main() {
  TextOut(0, LCD_LINE1, "Hello World");
}

RobotC LEGO Mindstorms NXT

task main() {
  displayString(1, "Hello World");
}

EV3 MicroPython LEGO EV3

from pybricks.hubs import EV3Brick
ev3 = EV3Brick()
ev3.screen.print("Hello World")

Arduino C/C++

void setup() {
  Serial.begin(9600);
  Serial.println("Hello World");
}
void loop() {}

MicroPython ESP32 / RPi Pico

print("Hello World")

CircuitPython Adafruit

print("Hello World")

Toit IoT ESP32

main:
  print "Hello World"

VHDL Hardware Description

entity hello is end;
architecture rtl of hello is
begin
  process begin
    report "Hello World";
    wait;
  end process;
end rtl;

Verilog Hardware Description

module main;
  initial begin
    $display("Hello World");
  end
endmodule

SystemVerilog Verification

module main;
  initial begin
    $display("Hello World");
  end
endmodule

Chisel Scala → Verilog

printf("Hello World\n")

SpinalHDL Scala → VHDL

report("Hello World")

GLSL Fragment Shader

// GLSL: pas de texte, convention pixel:
void main() {
  gl_FragColor = vec4(0.42, 0.32, 0.0, 1.0);
}

HLSL DirectX Shader

float4 main() : SV_Target {
  return float4(0.42, 0.32, 0.0, 1.0);
}

Metal Apple GPU

#include <metal_stdlib>
kernel void hello(device char* out [[buffer(0)]]) {
  // "Hello World" encoded conceptually
}

CUDA C++ NVIDIA GPU

#include <cstdio>
__global__ void hello() {
  printf("Hello World\n");
}
int main() { hello<<<1,1>>>(); cudaDeviceSynchronize(); }

OpenCL C Khronos GPU

__kernel void hello() {
  printf("Hello World\n");
}

SYCL Khronos C++ GPU

#include <sycl/sycl.hpp>
int main() {
  sycl::queue q;
  q.submit([&](auto& h) {
    sycl::stream out(1024, 256, h);
    h.single_task([=] { out << "Hello World"; });
  });
}

WebAssembly Text WAT

(module
  (func $hello (import "env" "log") (param i32 i32))
  (data (i32.const 0) "Hello World")
  (func (export "main") (call $hello (i32.const 0) (i32.const 11)))
)

OpenSCAD 3D Modelling

echo("Hello World");

LabVIEW G textuel equiv.

// LabVIEW est graphique : 
// [String Constant "Hello World"] → [Indicator]

Assembler ARM Cortex-M

.global main
main:
  ldr r0, =msg
  bl printf
  bx lr
msg: .asciz "Hello World\n"

Assembler RISC-V

.section .data
msg: .string "Hello World\n"
.section .text
.globl _start
_start:
  li a7, 64
  li a0, 1
  la a1, msg
  li a2, 12
  ecall

Embox RTOS C

#include <stdio.h>
int main() {
  printf("Hello World\n");
  return 0;
}

Zephyr RTOS C

#include <zephyr/kernel.h>
void main(void) {
  printk("Hello World\n");
}

FreeRTOS C Task

void vTaskHello(void *pvParameters) {
  printf("Hello World\n");
  vTaskDelete(NULL);
}

Siemens SCL PLC S7

FUNCTION_BLOCK "Hello"
BEGIN
  "HMI_Text" := 'Hello World';
END_FUNCTION_BLOCK

Beckhoff TwinCAT ST

PROGRAM MAIN
VAR sMsg : STRING := 'Hello World'; END_VAR
ADSLOGSTR(ADSLOG_MSGTYPE_HINT, sMsg);

CODESYS ST 3.5

PROGRAM PLC_PRG
VAR sOut : STRING := 'Hello World'; END_VAR

Allen-Bradley RSLogix ST

MSG_Text := 'Hello World';

GRAFCET SFC IEC 61131

STEP Init:
  ACTION: Display("Hello World");
END_STEP

CFC IEC 61131-3

[DISPLAY]──"Hello World"──[OUT]

Karel Fanuc Robot

PROGRAM hello
BEGIN
  WRITE('Hello World',CR)
END hello

RAPID ABB Robot

MODULE MainModule
  PROC main()
    TPWrite "Hello World";
  ENDPROC
ENDMODULE

KRL KUKA Robot

DEF hello()
  MsgNotify("Hello World")
END

V+ Adept Robot

.PROGRAM hello()
  TYPE "Hello World"
.END

INFORM Motoman / Yaskawa

NOP
MSG "Hello World"
END

URScript Universal Robots

textmsg("Hello World")

Fanuc G-code CNC

(MSG, Hello World)
M30

Heidenhain CNC Dialog

FN 16: F-PRINT "Hello World"

Mazatrol Mazak CNC

MSG[ Hello World ]

Simulink MATLAB Model

% Display block → 'Hello World'
disp('Hello World')

VHDL-AMS Analog/Mixed

entity hello is end;
architecture sim of hello is
begin
  process begin
    report "Hello World";
    wait;
  end process;
end sim;

SystemC C++ HDL

#include <systemc.h>
SC_MODULE(Hello) {
  SC_CTOR(Hello) { cout << "Hello World" << endl; }
};

Chisel Scala HDL

import chisel3._
class Hello extends Module {
  printf("Hello World\n")
}

Ada SPARK Verified

with Ada.Text_IO; use Ada.Text_IO;
procedure Hello with SPARK_Mode is
begin Put_Line("Hello World"); end Hello;

MISRA C Automotive

#include <stdio.h>
int main(void) {
  (void)printf("Hello World\n");
  return 0;
}

ROS 2 Python Node

import rclpy
from rclpy.node import Node
class Hi(Node):
    def __init__(self):
        super().__init__('hello')
        self.get_logger().info('Hello World')

ROS 2 C++ Node

#include "rclcpp/rclcpp.hpp"
int main(int argc, char **argv) {
  rclcpp::init(argc, argv);
  auto node = rclcpp::Node::make_shared("hello");
  RCLCPP_INFO(node->get_logger(), "Hello World");
}

SCADA WinCC Script

HMIRuntime.Trace("Hello World")

OPC UA Python Client

from opcua import Client
c = Client("opc.tcp://localhost:4840")
c.connect()
print("Hello World")

Zenon SCADA VBA

Sub Hello()
  MsgBox "Hello World"
End Sub

GE iFIX VBA Script

Sub FixHello()
  Debug.Print "Hello World"
End Sub

MicroPython ESP32

print("Hello World")  # MicroPython on ESP32

CircuitPython Adafruit

print("Hello World")  # CircuitPython

Zephyr RTOS C Embedded

#include <zephyr/kernel.h>
void main(void) {
  printk("Hello World\n");
}

RIOT OS IoT C

#include <stdio.h>
int main(void) {
  puts("Hello World");
  return 0;
}

Mbed OS ARM C++

#include "mbed.h"
int main() {
  printf("Hello World\n");
}

NuttX POSIX RTOS

#include <stdio.h>
int main(int argc, char *argv[]) {
  printf("Hello World\n");
  return 0;
}

MyHDL Python HDL

from myhdl import *
def hello():
    print("Hello World")
hello()

Amaranth HDL Python FPGA

from amaranth import *
print("Hello World")  # Amaranth HDL setup

BSV Bluespec SV

module mkHello(Empty);
  rule say;
    $display("Hello World");
    $finish;
  endrule
endmodule

Clash Haskell HDL

topEntity = "Hello World" :: String

AHDL Altera HDL

-- AHDL: Hello World via LED register
SUBDESIGN hello (q[7..0] : OUTPUT;)
BEGIN q[] = B"01001000"; -- 'H'
END;

TLA+ Specification

---- MODULE Hello ----
INIT == PrintT("Hello World")
====

Alloy Model Checker

sig Hello { message: one String }
fact { Hello.message = "Hello World" }

DRAKON Visual Algo

[Action: print("Hello World")]

B&R AS Automation Studio

PROGRAM _INIT
  msg := 'Hello World';
END_PROGRAM

STEP 7 AWL Siemens IL

L     'H'
T     DB1.DBB0
// Hello World via IL

PSoC Creator Cypress C

#include "project.h"
int main(void) {
  UART_Start();
  UART_PutString("Hello World");
}

STM32 HAL ARM C

HAL_UART_Transmit(&huart2, (uint8_t*)"Hello World", 11, 1000);

ESP-IDF Espressif C

#include "esp_log.h"
void app_main(void) {
  ESP_LOGI("TAG", "Hello World");
}

Arduino MKR WiFi IoT

void setup() {
  SerialUSB.begin(9600);
  SerialUSB.println("Hello World");
}
void loop() {}

Raspberry Pi Python GPIO

print("Hello World")  # RPi Python

PIO Assembly RP2040

.program hello
  pull
  out pins, 8  ; 'H' = Hello World

OpenPLC Structured Text

PROGRAM hello
VAR msg : STRING := 'Hello World'; END_VAR
END_PROGRAM

Omron ST Sysmac PLC

sMsg := 'Hello World';

Mitsubishi GX ST PLC

D0 := 'Hello World';

ABB IRC5 RAPID v2

PROC main()
  TPWrite "Hello World";
ENDPROC

Staubli VAL3 Robot

begin
  putln("Hello World")
end

TwinCAT 3 ST Beckhoff

PROGRAM MAIN
VAR
  sMsg : STRING := 'Hello World';
END_VAR

Phoenix Contact ST PLCnext

PROGRAM Main
VAR
  msg : STRING := 'Hello World';
END_VAR

Delta DVP PLC

MOV "Hello World" D100

Keyence KV Script PLC

PRINT "Hello World"

Omron NJ ST Sysmac

sMessage := 'Hello World';

RSLogix 5000 Allen-Bradley

MSG_String := 'Hello World';

Unity Pro ST Schneider

message := 'Hello World';

GE Fanuc PME Emerson

PRINT "Hello World"

PNOZmulti Pilz Safety

// Safety Message: Hello World

CODESYS V3 IEC 61131

PROGRAM Main
VAR
  sMsg : STRING := 'Hello World';
END_VAR

Mitsubishi GX Works MELSEC

MOV "Hello World" D0

Yokogawa CENTUM DCS

PRINT "Hello World"

ABB Rapid Robot

PROC main()
  TPWrite "Hello World";
ENDPROC

FANUC Karel Robot

PROGRAM hello
BEGIN
  WRITE('Hello World')
END hello

Kawasaki AS Robot

PROGRAM hello
  PRINT "Hello World"
END

Epson SPEL+ Robot

Function main
  Print "Hello World"
Fend

Denso PacScript Robot

Sub Main
  PrintMsg "Hello World"
End Sub

Yaskawa Inform Robot

NOP
MSG "Hello World"
END

Comau PDL2 Robot

PROGRAM hello
BEGIN
  WRITE LUN_CRT ("Hello World")
END hello

NACHI FD Robot

PRINT "Hello World"

Doosan DRL Cobot

tp_popup("Hello World")

UR Script Universal Robot

textmsg("Hello World")

Techman TMflow Cobot

display("Hello World")

B&R Automation Studio ST

sMessage := 'Hello World';

Wago e!COCKPIT PLC ST

sHello := 'Hello World';

Lenze PLC Designer IEC

msg := 'Hello World';

Beckhoff TwinSAFE Safety PLC

// SafeMessage: Hello World

KUKA KRL Robot

DEF hello()
  MsgNotify("Hello World")
END

NACHI Teach Pendant

MSG "Hello World"

Adept V+ Omron Robot

TYPE "Hello World"

Mitsubishi MELFA Robot

10 M1$="Hello World"
20 PRINT M1$

Codesys CFC Continuous FC

// CFC Box: STRING 'Hello World'

Profinetio GSD Config

<!-- Hello World Device -->

Arduino AVR C++

void setup() {
  Serial.begin(9600);
  Serial.println("Hello World");
}
void loop() {}

MicroPython ESP32

print("Hello World")

CircuitPython Adafruit

print("Hello World")

Zephyr RTOS C Embed

#include <zephyr/kernel.h>
void main(void) {
  printk("Hello World\n");
}

FreeRTOS Task C

void hello_task(void *pvParam) {
  printf("Hello World\n");
  vTaskDelete(NULL);
}

mbed OS ARM C++

#include "mbed.h"
int main() {
  printf("Hello World\n");
}

Toit IoT Language

main:
  print "Hello World"

MonkeyC Garmin

Toybox.System.println("Hello World");

Embedded Swift Apple MCU

print("Hello World")

NuttX Shell RTOS

nsh> echo Hello World

TI-BASIC Calculator

:Disp "HELLO WORLD"

Langages blockchain & smart contracts 0

Langages pour smart contracts, blockchain, DeFi et applications décentralisées.

Solidity Ethereum / EVM

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract HelloWorld {
  function hello() public pure returns (string memory) {
    return "Hello World";
  }
}

Vyper Ethereum / EVM

@external
@view
def hello() -> String[11]:
    return "Hello World"

Move Sui / Aptos

module hello::hello {
  use std::debug;
  public entry fun say_hello() {
    debug::print(&b"Hello World");
  }
}

Cadence Flow Blockchain

access(all) fun main(): String {
  return "Hello World"
}

Michelson Tezos

parameter unit;
storage string;
code { DROP; PUSH string "Hello World";
       NIL operation; PAIR }

SmartPy Tezos Python

import smartpy as sp
@sp.module
def main():
    class Hello(sp.Contract):
        @sp.entrypoint
        def default(self):
            sp.trace("Hello World")

LIGO Tezos CameLIGO

let main () : operation list * string =
  ([], "Hello World")

Cairo StarkNet

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

Noir Aztec ZK-Proofs

fn main() {
    std::println("Hello World");
}

Leo Aleo zkSNARK

program hello.aleo {
  transition main() -> u32 {
    return 0u32; // conceptual Hello World
  }
}

Sophia Aeternity

contract HelloWorld =
  entrypoint hello() = "Hello World"

Clarity Stacks / Bitcoin

(define-read-only (hello)
  (ok "Hello World"))

Plutus Cardano Haskell

hello :: BuiltinString
hello = "Hello World"

Aiken Cardano

// Aiken compile validator, pas d'I/O texte directe
trace "Hello World"

Ink! Polkadot / Substrate

#[ink::contract]
mod hello {
    #[ink(message)]
    pub fn hello(&self) -> String {
        String::from("Hello World")
    }
}

CosmWasm Cosmos Rust

pub fn hello() -> StdResult<Response> {
    Ok(Response::new().add_attribute("msg", "Hello World"))
}

Scilla Zilliqa

contract HelloWorld()
  field msg : String = "Hello World"

FunC TON Blockchain

() recv_internal() {
  ~dump_stack();
  ;; Hello World conceptuel
}

Tact TON Modern

contract Hello {
  receive() {
    dump("Hello World");
  }
}

Solana Anchor / Rust

use anchor_lang::prelude::*;
#[program]
pub mod hello {
    pub fn say_hello(ctx: Context<SayHello>) -> Result<()> {
        msg!("Hello World");
        Ok(())
    }
}

Clarity Stacks / Bitcoin

(print "Hello World")

Cairo StarkNet

fn main() {
    'Hello World'.print();
}

Move Aptos

module hello::message {
    use std::debug;
    public entry fun say() {
        debug::print(&b"Hello World");
    }
}

Sway Fuel Network

contract;
abi Hello { fn say() -> str[11]; }
impl Hello for Contract {
    fn say() -> str[11] { "Hello World" }
}

Plutus Cardano Haskell

helloWorld :: BuiltinString
helloWorld = "Hello World"

Aiken Cardano

pub fn hello() -> ByteArray {
  "Hello World"
}

CosmWasm Rust Contract

pub fn execute(deps: DepsMut, _env: Env, _info: MessageInfo, _msg: ExecuteMsg) -> StdResult<Response> {
    Ok(Response::new().add_attribute("message", "Hello World"))
}

Scilla Zilliqa

contract Hello()
transition SayHello()
  e = {_eventname: "Hello"; msg: "Hello World"};
  event e
end

Michelson Tezos Low-level

parameter unit;
storage string;
code { DROP; PUSH string "Hello World"; NIL operation; PAIR }

SmartPy Tezos Python

import smartpy as sp
class Hello(sp.Contract):
    def __init__(self):
        self.init(msg = "Hello World")

LIGO Tezos CameLIGO

let main () : string = "Hello World"

Reach DApp

'reach 0.1';
export const main = Reach.App(() => {
  const A = Participant('Alice', {});
  deploy();
  A.publish(); commit();
});

TEAL Algorand

#pragma version 8
byte "Hello World"
log
int 1
return

PyTeal Algorand Python

from pyteal import *
def hello():
    return Seq(Log(Bytes("Hello World")), Approve())

Noir Aztec ZK

fn main() {
    std::println("Hello World");
}

Huff EVM Assembly

#define macro MAIN() = {
  0x48656C6C6F // "Hello"
  0x00 mstore
  0x20 0x00 return
}

FunC TON Blockchain

() recv_internal() impure {
  ~dump("Hello World");
}

Tact TON High-level

contract Hello {
    receive() { dump("Hello World"); }
}

Cadence Flow Blockchain

access(all) fun main(): String {
    return "Hello World"
}

Ride Waves Blockchain

@Callable(i)
func hello() = {
  [StringEntry("msg", "Hello World")]
}

Marlowe Cardano Financial

Close -- Simplified: Hello World contract
-- full: When [Deposit ...] timeout Close

Fe Ethereum Rust-like

contract Hello {
  pub fn say(self) {
    emit Greet(msg: "Hello World")
  }
}

Serpent Ethereum Legacy

def hello():
    log("Hello World")

LLL Ethereum Low-level

(seq
  (mstore 0x00 "Hello World")
  (return 0x00 0x20))

Ink! Substrate / Polkadot

#[ink::contract]
mod hello {
    #[ink(message)]
    pub fn say(&self) -> String {
        String::from("Hello World")
    }
}

Sophia Æternity

contract Hello =
  entrypoint hello() : string = "Hello World"

Pact Kadena

(module hello G
  (defcap G () true)
  (defun say () "Hello World")
)

Motoko Internet Computer

actor Hello {
  public query func say() : async Text {
    "Hello World"
  };
};

Bamboo Ethereum Exp.

contract Hello(string greeting) {
  default {
    greeting = "Hello World";
    return;
  }
}

DeepSEA Verified EVM

external hello() returns string {
  return "Hello World";
}

Sway (FuelVM) Predicate

predicate;
fn main() -> bool {
  log("Hello World");
  true
}

Archetype Tezos DSL

archetype hello
variable msg : string = "Hello World"

Solang Solidity for Solana

contract Hello {
  function say() public pure returns (string memory) {
    return "Hello World";
  }
}

Soroban Stellar Rust

pub fn hello(env: Env) -> String {
    String::from_str(&env, "Hello World")
}

Yul EVM Assembly

object "Hello" {
  code {
    mstore(0, "Hello World")
    return(0, 32)
  }
}

sBTC Stacks Bitcoin L2

(print "Hello World from sBTC")

Leo Aleo ZK

program hello.aleo {
  transition main() -> field {
    return 42field; // Hello World
  }
}

Sui Move Mysten Labs

module hello::hello {
  use std::debug;
  public entry fun say_hello() {
    debug::print(&b"Hello World");
  }
}

Aptos Move Move 2

module hello::message {
  use std::debug;
  public fun hello() {
    debug::print(&b"Hello World");
  }
}

Soroban Stellar Rust

#[contractimpl]
impl HelloContract {
  pub fn hello(env: Env) -> String {
    String::from_str(&env, "Hello World")
  }
}

ink! Polkadot

#[ink::contract]
mod hello {
  #[ink(message)]
  pub fn hello(&self) -> String {
    String::from("Hello World")
  }
}

NEAR SDK Rust

#[near_bindgen]
impl Contract {
  pub fn hello(&self) -> String {
    "Hello World".to_string()
  }
}

SmartPy Tezos Python

import smartpy as sp

@sp.module
def main():
  class Hello(sp.Contract):
    @sp.entrypoint
    def hello(self):
      sp.trace("Hello World")

Aiken Cardano

fn hello() -> ByteArray {
  "Hello World"
}

MultiversX Elrond Rust

#[elrond_wasm::contract]
pub trait Hello {
  #[endpoint]
  fn hello(&self) -> ManagedBuffer {
    ManagedBuffer::from("Hello World")
  }
}

FunC TON

() recv_internal() impure {
  ;; Hello World
}

Tact TON Modern

contract Hello {
  receive() {
    dump("Hello World");
  }
}

Cairo 1.0 Starknet

fn main() {
    'Hello World'.print();
}

Noir Aztec ZK

fn main() {
    std::println("Hello World");
}

Circom ZK Circuits

template Hello() {
  signal output out;
  out <-- 42; // Hello World
}

Sway Fuel Network

contract;
abi Hello {
  fn hello() -> str[11];
}
impl Hello for Contract {
  fn hello() -> str[11] {
    "Hello World"
  }
}

Reach DApp DSL

'reach 0.1';
export const main = Reach.App(() => {
  const A = Participant('Alice', {});
  deploy();
  // Hello World
});

Marlowe Cardano Financial

When []
  (TimeParam "deadline")
  Close
-- Hello World contract

Scilla Zilliqa

scilla_version 0
contract Hello()
field msg : String = "Hello World"

Ligo Tezos ML

let main (_, s : unit * string) : operation list * string =
  ([], "Hello World")

Archetype Tezos Formal

archetype hello
variable msg : string = "Hello World"

Huff EVM Assembly

#define macro MAIN() = takes(0) returns(0) {
  0x48656c6c6f20576f726c64 // Hello World
}

Fe EVM Rust-like

contract Hello {
  pub fn hello() -> String<11> {
    return String<11>("Hello World")
  }
}

Plutus Cardano Haskell

{-# INLINABLE hello #-}
hello :: BuiltinString
hello = "Hello World"

Helios Cardano DSL

spending hello
func main(_, _, _) -> Bool {
  print("Hello World");
  true
}

Ride Waves

@Callable(i)
func hello() = {
  [StringEntry("msg", "Hello World")]
}

Pact Kadena

(module hello GOVERNANCE
  (defun say-hello () "Hello World")
)

Clarity Stacks Bitcoin

(define-read-only (hello)
  (ok "Hello World")
)

Rell Chromia

operation hello() {
  print("Hello World");
}

Move Diem/Libra

module 0x1::hello {
  public fun say(): vector<u8> {
    b"Hello World"
  }
}

Algorand TEAL AVM

#pragma version 8
byte "Hello World"
log
int 1

PyTeal Algorand Python

from pyteal import *
program = Log(Bytes("Hello World"))
print(compileTeal(program, Mode.Application))

Beaker Algorand Framework

@external
def hello(*, output: abi.String):
    return output.set("Hello World")

Cadence Flow Blockchain

access(all) fun main(): String {
  return "Hello World"
}

CosmWasm Cosmos Rust

#[entry_point]
pub fn instantiate(
  _deps: DepsMut, _env: Env,
  _info: MessageInfo, _msg: InstantiateMsg,
) -> StdResult<Response> {
  Ok(Response::new().add_attribute("message", "Hello World"))
}

Solang Solidity Solana

contract Hello {
  function hello() public pure returns (string memory) {
    return "Hello World";
  }
}

Hoon Urbit

:-  %say
|=  *
:-  %noun
"Hello World"

Simplicity Bitcoin Script

-- Hello World (typed combinator)
main = unit

Michelson Tezos VM

parameter unit;
storage string;
code { DROP;
       PUSH string "Hello World";
       NIL operation;
       PAIR }

Yul EVM Assembly

object "Hello" {
  code {
    mstore(0, "Hello World")
    return(0, 32)
  }
}

Polkadot ink! 5 v5 WASM

#[ink::contract]
mod hello {
  #[ink(message)]
  pub fn hello(&self) -> String {
    "Hello World".into()
  }
}

Starknet Contracts Cairo 2

#[starknet::contract]
mod hello {
  fn hello() -> felt252 {
    'Hello World'
  }
}

Hyperledger Fabric Go CC

func (s *SmartContract) Hello(ctx contractapi.TransactionContextInterface) string {
  return "Hello World"
}

DAML Digital Asset

template Hello with
    owner : Party
  where
    signatory owner
    -- Hello World

Ergo Accord Project

contract Hello over TemplateModel {
  clause hello() : String {
    return "Hello World"
  }
}

Sophia Aeternity

contract Hello =
  entrypoint hello() = "Hello World"

Liquidity Tezos OCaml

let%entry main () _ =
  ([], "Hello World")

Langages audio & créatifs 0

Langages pour la musique, la synthèse audio, le live-coding et les arts visuels génératifs.

SuperCollider Audio Synthesis

"Hello World".postln;

SuperCollider SynthDef

SynthDef(\hello, {
  Out.ar(0, SinOsc.ar(440) * 0.2)
}).add;
"Hello World".postln;

ChucK Music Programming

<<< "Hello World" >>>;

Csound Computer Music

<CsoundSynthesizer>
<CsInstruments>
instr 1
  prints "Hello World\n"
endin
</CsInstruments>
<CsScore>
i 1 0 1
</CsScore>
</CsoundSynthesizer>

Sonic Pi Live Coding Music

puts "Hello World"
play :c4

Faust Audio DSP

// Faust traite du signal, pas du texte
// "Hello World" = un sinus 440Hz
process = os.osc(440);

TidalCycles Haskell Live Coding

d1 $ sound "hello"
-- plus conventionnel:
putStrLn "Hello World"

Overtone Clojure Audio

(println "Hello World")
(demo (sin-osc 440))

LilyPond Music Engraving

\markup { "Hello World" }
\relative c' { c4 d e f | g2 g }

ABC Notation Folk Music

X:1
T:Hello World
M:4/4
K:C
C D E F | G2 G2 |

MusicXML Standard partition

<score-partwise>
  <part id="P1">
    <measure number="1">
      <!-- Hello World en notation musicale -->
    </measure>
  </part>
</score-partwise>

Max/MSP Visual Audio Cycling74

[message: "Hello World"] → [print]

Pure Data pd audio

[msg "Hello World"(
|
[print]

Extempore Live Coding

(println "Hello World")

Gibber JS Audio Live

log("Hello World")

Hydra Visual Live Coding

// Hydra = visual shader live coding
osc(10, 0.1).out() // visual "Hello World"

p5.js Art génératif

function setup() {
  createCanvas(400, 200);
  textSize(32);
  text("Hello World", 50, 100);
}

Processing Java Art

void setup() {
  size(300, 200);
  textSize(32);
  text("Hello World", 10, 100);
}

openFrameworks C++ Art

void ofApp::draw(){
  ofDrawBitmapString("Hello World", 20, 20);
}

Cinder C++ Creative

void MyApp::draw() {
  gl::clear();
  gl::drawString("Hello World", vec2(20, 20));
}

TouchDesigner Visual Nodes

[Text DAT: "Hello World"] → [Out DAT]

vvvv Visual Programming

[IOBox (String)] ← "Hello World" → [Renderer]

Nannou Rust Creative

fn view(app: &App, frame: Frame) {
    let draw = app.draw();
    draw.text("Hello World");
    draw.to_frame(app, &frame).unwrap();
}

Shadertoy GLSL en ligne

void mainImage(out vec4 fragColor, in vec2 fragCoord) {
    fragColor = vec4(0.42, 0.32, 0.0, 1.0);
    // Visual "Hello World" pixel shader
}

ORCA Esoteric Sequencer

.D8.....
.:Hello.
.World!.

Node-RED IoT Visual Flow

[Inject "Hello World"] → [Debug msg.payload]

Faust DSP Language

// Hello World as silent pass-through
process = _;

SOUL Audio DSP

processor Hello {
    output stream float out;
    void run() { advance(); }
}

RNBO Max/MSP Export

[loadmess Hello World] → [print]

Max/MSP Message Box

[button] → [message "Hello World"] → [print]

Reaktor Core NI

// Reaktor: Macro → Text "Hello World"

Cabbage Csound GUI

instr 1
  prints "Hello World\n"
endin

FoxDot Python Live

print("Hello World")
p1 >> pluck([0,2,4])

Gibber JS Audio

log('Hello World')
Synth('bleep').note(0)

Strudel TidalCycles Web

// Hello World rhythm
s("bd sd").log("Hello World")

Hydra Visual Live-coding

osc(10,0.1).color(1,0,0).out()
// Hello World visuals

GLSL Fragment Shader

void main() {
  gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
  // Hello World = red screen
}

HLSL DirectX Shader

float4 PSMain() : SV_TARGET {
  return float4(0, 1, 0, 1); // Hello World green
}

Metal Apple Shader

fragment float4 hello() {
  return float4(0, 0, 1, 1); // Hello World blue
}

WGSL WebGPU Shader

@fragment fn main() -> @location(0) vec4f {
  return vec4f(1, 1, 0, 1); // Hello World yellow
}

Audulus Modular App

// Text node: "Hello World"
// → Speaker output

VCV Rack Module DSP

// Module: "Hello World" label
// → Audio output 0dB

LiveCode Sound

put "Hello World" into field 1
play "boing"

LÖVE 2D Lua Audio

function love.draw()
  love.graphics.print("Hello World", 100, 100)
end

Godot GDScript

extends Node
func _ready():
    print("Hello World")

Alda Music Notation

piano:
  c8 d e f g2 | # Hello World melody

Nyquist Audio Synth

(print "Hello World")

CLM Common Lisp Music

(format t "Hello World~%")

Kyma Sound Design

`Hello World` asSound play

OpenMusic IRCAM Visual

;; OM patch: TextBox "Hello World"

Impromptu Scheme Audio

(print "Hello World")

Shadertoy GLSL Web

void mainImage(out vec4 o, vec2 uv) {
  o = vec4(1,0,0,1); // Hello World red
}

Nannou Rust Creative

fn view(app: &App, frame: Frame) {
    let draw = app.draw();
    draw.text("Hello World");
    draw.to_frame(app, &frame).unwrap();
}

openFrameworks C++ Creative

void ofApp::draw(){
  ofDrawBitmapString("Hello World", 20, 20);
}

Cinder C++ Creative

void MyApp::draw() {
  gl::drawString("Hello World", vec2(20, 20));
}

three.js 3D WebGL

const loader = new FontLoader();
loader.load('font.json', font => {
  const geo = new TextGeometry('Hello World', {font});
  scene.add(new Mesh(geo, material));
});

TouchDesigner Visual

# Text TOP → "Hello World"

vvvv gamma Visual Reactive

// TextNode: "Hello World" → Renderer

Pure Data Pd Vanilla

[loadbang]
|
[symbol Hello World]
|
[print]

SuperCollider Pattern

("Hello World").postln;

TidalCycles Pattern

-- Hello World as a pattern
d1 $ s "bd sd" # note "c e g"

Extempore Live Sys

(sys:load "libs/core/audio_dsp.xtm")
(println "Hello World")

Overtone Clojure Audio

(println "Hello World")
(demo (sin-osc 440))

Csound Orchestra

instr 1
  prints "Hello World\n"
endin
scoreline_i "i1 0 1"

MusicXML Notation

<credit><credit-words>Hello World</credit-words></credit>

Orca Sequencer

..H.e.l.l.o..W.o.r.l.d..

Sardine Python Live

@swim
def hello(p=0.5):
    print("Hello World")
    again(hello)

Mercury Live Coding

new sample hello
  set hello note("Hello World")

Glicol Rust Audio

// Hello World in Glicol
hello: imp 1.0 >> mul 0.5

Gibber Web Audio

Theory.note('c4').trigger()
// Hello World

Strudel Tidal Web

s("bd sd").log("Hello World")

Hydra Visual Synth

osc(10, 0.1).out()
// Hello World visuals

FoxDot SC Python

print("Hello World")
p1 >> pluck([0, 2, 4])

Overtone Clojure Music

(println "Hello World")
(demo (sin-osc 440))

Alda Music Programming

piano:
  c8 d e f g a b > c
  # Hello World

Sonic Pi v4 Live

puts "Hello World"
play 60

Pure Data Pd Vanilla

[print Hello World(

FAUST DSP Signal

process = _ : +(0) : _; // Hello World

Extempore Live Code

(println "Hello World")

Sporth Stack Audio

# Hello World
440 0.5 sine

Vortex Audio Visual

print("Hello World")

Tidal 2.0 Haskell Beats

d1 $ s "hello" # note "c5"
-- Hello World

ixi lang Live Minimal

agent -> hello world

Fluxus Scheme 3D

(display "Hello World")

Kyma Symbolic Sound

!"Hello World" printString

MPEG-4 SA Structured Audio

// Hello World signal
instr hello()
  { aout = 0.5 * oscil(440); }

Nyquist CMU Audio

(print "Hello World")
(play (osc 60))

CMusic Princeton

; Hello World
i1 0 1 440

RTcmix Real-Time

print("Hello World")
WAVETABLE(0, 1, 20000, 440)

CLM Common Lisp Music

(format t "Hello World~%")
(with-sound () (fm-violin 0 1 440 .1))

HMSL Forth Music

." Hello World" CR

Mosaic UCSB Audio

; Hello World
play 440 1.0

Max/MSP Cycling '74

[message: Hello World] -> [print]

Reaktor Core NI

// Core Cell: "Hello World" -> Terminal

Cabbage Csound GUI

form caption("Hello World") size(400,300)

SOUL Audio DSL

processor Hello {
  output stream float out;
  void run() { advance(); /* Hello World */ }
}

Cmajor SOUL Successor

processor Hello {
  output stream float out;
  void main() { /* Hello World */ advance(); }
}

Tidal Strudel JS Patterns

note("c3 e3 g3").log("Hello World")

Gwion ChucK-like

<<<"Hello World">>>;

Spatialized Ambisonics

// 3D Audio: Hello World
osc.send("/hello", "world")

JSFX Reaper Script

desc:Hello World
@sample
spl0 = spl0;

VCV Rack Modular Plugin

// Module: Hello World
void process() { outputs[0].setVoltage(5.f); }

Bela Real-Time Audio

bool setup(BelaContext *context, void *) {
  rt_printf("Hello World\n");
  return true;
}

Norns Script Monome Lua

function init()
  print("Hello World")
end

Teletype Monome Script

TR.P 1
# Hello World

Wwise Audio Engine

// Event: Play_HelloWorld
AK::SoundEngine::PostEvent("Play_HelloWorld", gameObj);

FMOD Audio Middleware

FMOD::Studio::EventInstance* event;
system->getEvent("event:/HelloWorld", &event);
event->start();

Puredata Gem Visual

[gemwin]
[text3d Hello World]

Processing Sound Audio Lib

import processing.sound.*;
void setup() { println("Hello World"); }

p5.sound Web Audio

function setup() {
  createCanvas(400, 400);
  text('Hello World', 50, 50);
}

Gibber Live Coding Audio

// Gibber - Hello World sonore
Synth('bleep').note.seq([0,1,2], 1/4)
Log('Hello World')

Extempore Live Coding

(sys:load "libs/core/instruments.xtm")
(println "Hello World")

Orca Esoteric Sequencer

.Hello.World.
:03C (MIDI output)