Home

title: Reword This MDX Content description: An example MDX document to be reworded.

Let's Get Started!

This is some example content that needs to be reworded. The goal is to alter the wording significantly while ensuring the original meaning is precisely maintained.

Here's a sentence with a link.

const myVariable = "Hello, world!";
console.log(myVariable);

Here's an image:

And another sentence to be rephrased. This one should also be changed quite a bit.

Finally, a concluding statement.

This statement should also be reworded.

def my_function():
 print("Hello from Python!")

function MyComponent() {
 return <h1>Hello from React!</h1>;
}

interface MyInterface {
 name: string;
 age: number;
}

{
 "key": "value"
}

echo "Hello from the command line!"

using System;


public class MyClass
{
 public static void Main(string[] args)
 {
 Console.WriteLine("Hello from C#!");
 }
}

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

package main


import "fmt"


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

puts "Hello from Ruby!"

fun main() {
 println("Hello from Kotlin!")
}

print("Hello from Swift!")

fn main() {
 println!("Hello from Rust!");
}

<?php
echo "Hello from PHP!";
?>

SELECT * FROM users;

<!DOCTYPE html>
<html>
<head>
 <title>Hello World</title>
</head>
<body>
 <h1>Hello World</h1>
</body>
</html>

key: value

<root>
 <element>value</element>
</root>

[section]
key = value

print("Hello from Lua!")

print("Hello from R!")

void main() {
 print('Hello from Dart!');
}

object Main {
 def main(args: Array[String]): Unit = {
 println("Hello from Scala!")
 }
}

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


main() ->
 io:format("Hello from Erlang!~n").

IO.puts "Hello from Elixir!"

printfn "Hello from F#!"

console.log "Hello from CoffeeScript!"

Module Module1
 Sub Main()
 Console.WriteLine("Hello from VB.NET!")
 End Sub
End Module

with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line("Hello from Ada!");
end Hello;

section .data
 msg db 'Hello, world!', 0


section .text
 global _start


_start:
 ; Write the message to stdout
 mov rax, 1  ; syscall number for write
 mov rdi, 1  ; file descriptor 1 is stdout
 mov rsi, msg ; address of string to output
 mov rdx, 13 ; number of bytes to write
 syscall


 ; Exit the program
 mov rax, 60 ; syscall number for exit
 xor rdi, rdi ; exit code 0
 syscall

program hello
 print *, "Hello from Fortran!"
end program hello

program Hello;
begin
 Writeln('Hello from Pascal!');
end.

hello :-
 write('Hello from Prolog!'), nl.

(display "Hello from Scheme!")
(newline)

puts "Hello from Tcl!"

Write-Host "Hello from PowerShell!"

#include <stdio.h>


int main() {
 printf("Hello from C!\n");
 return 0;
}

#include <iostream>


int main() {
 std::cout << "Hello from C++!" << std::endl;
 return 0;
}

#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Hello from Objective-C!");
 }
 return 0;
}

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello from COBOL!".
 STOP RUN.

println("Hello from Julia!")

(print "Hello from Lisp!")

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 process
 begin
 report "Hello from VHDL!";
 wait;
 end process;
end Behavioral;

module hello;
 initial begin
 $display("Hello from Verilog!");
 $finish;
 end
endmodule

disp('Hello from MATLAB!');

section .data
 msg db 'Hello, world!', 0


section .text
 global _start


_start:
 ; Write the message to stdout
 mov rax, 1  ; syscall number for write
 mov rdi, 1  ; file descriptor 1 is stdout
 mov rsi, msg ; address of string to output
 mov rdx, 13 ; number of bytes to write
 syscall


 ; Exit the program
 mov rax, 60 ; syscall number for exit
 xor rdi, rdi ; exit code 0
 syscall

program HelloWorld;


begin
 Writeln('Hello from Delphi!');
 Readln;
end.

with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line("Hello from Ada!");
end Hello;

'Hello from APL!'

BEGIN { print "Hello from Awk!" }

PRINT "Hello from BASIC!"

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

(println "Hello from Clojure!")

puts "Hello from Crystal!"

import std.stdio;


void main() {
 writeln("Hello from D!");
}

class
 HELLO_WORLD


create
 make


feature


 make
 do
 print ("Hello from Eiffel!%N")
 end


end

." Hello from Forth!" cr
bye

main = putStrLn "Hello from Haskell!"

procedure main()
 write("Hello from Icon!")
end

'Hello from J!'

console.log("Hello from JavaScript!");

println("Hello from Julia!")

fun main() {
 println("Hello from Kotlin!")
}

(print "Hello from Lisp!")

print("Hello from Lua!")

Print["Hello from Mathematica!"]

#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Hello from Objective-C!");
 }
 return 0;
}

print_endline "Hello from OCaml!"

program HelloWorld;


begin
 Writeln('Hello from Pascal!');
 Readln;
end.

print "Hello from Perl!\n";

<?php
echo "Hello from PHP!";
?>

BEGIN
 DBMS_OUTPUT.PUT_LINE('Hello from PL/SQL!');
END;
/

hello :-
 write('Hello from Prolog!'), nl.

print("Hello from Python!")

print("Hello from R!")

#lang racket
(displayln "Hello from Racket!")

puts "Hello from Ruby!"

fn main() {
 println!("Hello from Rust!");
}

object Main {
 def main(args: Array[String]): Unit = {
 println("Hello from Scala!")
 }
}

(display "Hello from Scheme!")
(newline)

Transcript show: 'Hello from Smalltalk!'; cr.

SELECT 'Hello from SQL!';

print("Hello from Swift!")

puts "Hello from Tcl!"

console.log("Hello from TypeScript!");

Module Module1
 Sub Main()
 Console.WriteLine("Hello from VB.NET!")
 End Sub
End Module

module hello;
 initial begin
 $display("Hello from Verilog!");
 $finish;
 end
endmodule

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 process
 begin
 report "Hello from VHDL!";
 wait;
 end process;
end Behavioral;

Module Module1
 Sub Main()
 Console.WriteLine("Hello from Visual Basic!");
 End Sub
End Module

Print["Hello from Wolfram Language!"]

<message>Hello from XML!</message>

message: Hello from YAML!

echo "Hello from Zsh!"

console.log "Hello from CoffeeScript!"

void main() {
 print('Hello from Dart!');
}

IO.puts "Hello from Elixir!"

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


main() ->
 io:format("Hello from Erlang!~n").

printfn "Hello from F#!"

program hello
 print *, "Hello from Fortran!"
end program hello

package main


import "fmt"


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

println "Hello from Groovy!"

class Main {
 static public function main() {
 Sys.println("Hello from Haxe!");
 }
}

module Main


main : IO ()
main = putStrLn "Hello from Idris!"

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

execution {
 println@Console("Hello from Jolie!")
}

console.log "Hello from LiveScript!"

(print "Hello from Lisp!")

default
{
 state_entry()
 {
 llSay(0, "Hello from LSL!");
 }
}

disp('Hello from MATLAB!');

echo "Hello from Nim!"

{ pkgs ? import <nixpkgs> {} }:
pkgs.stdenv.mkDerivation {
 name = "hello";
 phases = "installPhase";
 installPhase = ''
 echo "Hello from Nix!"
 '';
}

#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Hello from Objective-C!");
 }
 return 0;
}

print_endline "Hello from OCaml!"

disp('Hello from Octave!');

{Show 'Hello from Oz!'}

program HelloWorld;


begin
 Writeln('Hello from Pascal!');
 Readln;
end.

print "Hello from Perl!\n";

<?php
echo "Hello from PHP!";
?>

BEGIN
 DBMS_OUTPUT.PUT_LINE('Hello from PL/SQL!');
END;
/

Write-Host "Hello from PowerShell!"

hello :-
 write('Hello from Prolog!'), nl.

module Main where


import Effect (Effect)
import Effect.Console (log)


main :: Effect Unit
main = log "Hello from PureScript!"

print("Hello from Python!")

/ Hello from Q

print("Hello from R!")

#lang racket
(displayln "Hello from Racket!")

print_endline("Hello from ReasonML!");

print "Hello from Rebol!"

see "Hello from Ring!" + nl

puts "Hello from Ruby!"

fn main() {
 println!("Hello from Rust!");
}

data _null_;
 put "Hello from SAS!";
run;

object Main {
 def main(args: Array[String]): Unit = {
 println("Hello from Scala!")
 }
}

(display "Hello from Scheme!")
(newline)

when green flag clicked
say [Hello from Scratch!] for 2 secs

Transcript show: 'Hello from Smalltalk!'; cr.

SELECT 'Hello from SQL!';

print("Hello from Swift!")

puts "Hello from Tcl!"

console.log("Hello from TypeScript!");

int main() {
 stdout.printf("Hello from Vala!\n");
 return 0;
}

Module Module1
 Sub Main()
 Console.WriteLine("Hello from VB.NET!")
 End Sub
End Module

module hello;
 initial begin
 $display("Hello from Verilog!");
 $finish;
 end
endmodule

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 process
 begin
 report "Hello from VHDL!";
 wait;
 end process;
end Behavioral;

Module Module1
 Sub Main()
 Console.WriteLine("Hello from Visual Basic!");
 End Sub
End Module

Print["Hello from Wolfram Language!"]

<message>Hello from XML!</message>

message: Hello from YAML!

echo "Hello from Zsh!"

const std = @import("std");


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

(println "Hello from Clojure!")

puts "Hello from Crystal!"

import std.stdio;


void main() {
 writeln("Hello from D!");
}

class
 HELLO_WORLD


create
 make


feature


 make
 do
 print ("Hello from Eiffel!%N")
 end


end

." Hello from Forth!" cr
bye

main = putStrLn "Hello from Haskell!"

procedure main()
 write("Hello from Icon!")
end

'Hello from J!'

console.log("Hello from JavaScript!");

println("Hello from Julia!")

fun main() {
 println("Hello from Kotlin!")
}

(print "Hello from Lisp!")

print("Hello from Lua!")

Print["Hello from Mathematica!"]

#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Hello from Objective-C!");
 }
 return 0;
}

print_endline "Hello from OCaml!"

disp('Hello from Octave!');

{Show 'Hello from Oz!'}

program HelloWorld;


begin
 Writeln('Hello from Pascal!');
 Readln;
end.

print "Hello from Perl!\n";

<?php
echo "Hello from PHP!";
?>

BEGIN
 DBMS_OUTPUT.PUT_LINE('Hello from PL/SQL!');
END;
/

Write-Host "Hello from PowerShell!"

hello :-
 write('Hello from Prolog!'), nl.

module Main where


import Effect (Effect)
import Effect.Console (log)


main :: Effect Unit
main = log "Hello from PureScript!"

print("Hello from Python!")

/ Hello from Q

print("Hello from R!")

#lang racket
(displayln "Hello from Racket!")

print_endline("Hello from ReasonML!");

print "Hello from Rebol!"

see "Hello from Ring!" + nl

puts "Hello from Ruby!"

fn main() {
 println!("Hello from Rust!");
}

data _null_;
 put "Hello from SAS!";
run;

object Main {
 def main(args: Array[String]): Unit = {
 println("Hello from Scala!")
 }
}

(display "Hello from Scheme!")
(newline)

when green flag clicked
say [Hello from Scratch!] for 2 secs

Transcript show: 'Hello from Smalltalk!'; cr.

SELECT 'Hello from SQL!';

print("Hello from Swift!")

puts "Hello from Tcl!"

console.log("Hello from TypeScript!");

int main() {
 stdout.printf("Hello from Vala!\n");
 return 0;
}

Module Module1
 Sub Main()
 Console.WriteLine("Hello from VB.NET!")
 End Sub
End Module

module hello;
 initial begin
 $display("Hello from Verilog!");
 $finish;
 end
endmodule

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 process
 begin
 report "Hello from VHDL!";
 wait;
 end process;
end Behavioral;

Module Module1
 Sub Main()
 Console.WriteLine("Hello from Visual Basic!");
 End Sub
End Module

Print["Hello from Wolfram Language!"]

<message>Hello from XML!</message>

message: Hello from YAML!

echo "Hello from Zsh!"

const std = @import("std");


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

(println "Hello from Clojure!")

puts "Hello from Crystal!"

import std.stdio;


void main() {
 writeln("Hello from D!");
}

class
 HELLO_WORLD


create
 make


feature


 make
 do
 print ("Hello from Eiffel!%N")
 end


end

." Hello from Forth!" cr
bye

main = putStrLn "Hello from Haskell!"

procedure main()
 write("Hello from Icon!")
end

'Hello from J!'

console.log("Hello from JavaScript!");

println("Hello from Julia!")

fun main() {
 println("Hello from Kotlin!")
}

(print "Hello from Lisp!")

print("Hello from Lua!")

Print["Hello from Mathematica!"]

#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Hello from Objective-C!");
 }
 return 0;
}

print_endline "Hello from OCaml!"

disp('Hello from Octave!');

{Show 'Hello from Oz!'}

program HelloWorld;


begin
 Writeln('Hello from Pascal!');
 Readln;
end.

print "Hello from Perl!\n";

<?php
echo "Hello from PHP!";
?>

BEGIN
 DBMS_OUTPUT.PUT_LINE('Hello from PL/SQL!');
END;
/

Write-Host "Hello from PowerShell!"

hello :-
 write('Hello from Prolog!'), nl.

module Main where


import Effect (Effect)
import Effect.Console (log)


main :: Effect Unit
main = log "Hello from PureScript!"

print("Hello from Python!")

/ Hello from Q

print("Hello from R!")

#lang racket
(displayln "Hello from Racket!")

print_endline("Hello from ReasonML!");

print "Hello from Rebol!"

see "Hello from Ring!" + nl

puts "Hello from Ruby!"

fn main() {
 println!("Hello from Rust!");
}

data _null_;
 put "Hello from SAS!";
run;

object Main {
 def main(args: Array[String]): Unit = {
 println("Hello from Scala!")
 }
}

(display "Hello from Scheme!")
(newline)

when green flag clicked
say [Hello from Scratch!] for 2 secs

Transcript show: 'Hello from Smalltalk!'; cr.

SELECT 'Hello from SQL!';

print("Hello from Swift!")

puts "Hello from Tcl!"

console.log("Hello from TypeScript!");

int main() {
 stdout.printf("Hello from Vala!\n");
 return 0;
}

Module Module1
 Sub Main()
 Console.WriteLine("Hello from VB.NET!")
 End Sub
End Module

module hello;
 initial begin
 $display("Hello from Verilog!");
 $finish;
 end
endmodule

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 process
 begin
 report "Hello from VHDL!";
 wait;
 end process;
end Behavioral;

Module Module1
 Sub Main()
 Console.WriteLine("Hello from Visual Basic!");
 End Sub
End Module

Print["Hello from Wolfram Language!"]

<message>Hello from XML!</message>

message: Hello from YAML!

echo "Hello from Zsh!"

const std = @import("std");


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

(println "Hello from Clojure!")

puts "Hello from Crystal!"

import std.stdio;


void main() {
 writeln("Hello from D!");
}

class
 HELLO_WORLD


create
 make


feature


 make
 do
 print ("Hello from Eiffel!%N")
 end


end

." Hello from Forth!" cr
bye

main = putStrLn "Hello from Haskell!"

procedure main()
 write("Hello from Icon!")
end

'Hello from J!'

console.log("Hello from JavaScript!");

println("Hello from Julia!")

fun main() {
 println("Hello from Kotlin!")
}

(print "Hello from Lisp!")

print("Hello from Lua!")

Print["Hello from Mathematica!"]

#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Hello from Objective-C!");
 }
 return 0;
}

print_endline "Hello from OCaml!"

disp('Hello from Octave!');

{Show 'Hello from Oz!'}

program HelloWorld;


begin
 Writeln('Hello from Pascal!');
 Readln;
end.

print "Hello from Perl!\n";

<?php
echo "Hello from PHP!";
?>

BEGIN
 DBMS_OUTPUT.PUT_LINE('Hello from PL/SQL!');
END;
/

Write-Host "Hello from PowerShell!"

hello :-
 write('Hello from Prolog!'), nl.

module Main where


import Effect (Effect)
import Effect.Console (log)


main :: Effect Unit
main = log "Hello from PureScript!"

print("Hello from Python!")

/ Hello from Q

print("Hello from R!")

#lang racket
(displayln "Hello from Racket!")

print_endline("Hello from ReasonML!");

print "Hello from Rebol!"

see "Hello from Ring!" + nl

puts "Hello from Ruby!"

fn main() {
 println!("Hello from Rust!");
}

data _null_;
 put "Hello from SAS!";
run;

object Main {
 def main(args: Array[String]): Unit = {
 println("Hello from Scala!")
 }
}

(display "Hello from Scheme!")
(newline)

when green flag clicked
say [Hello from Scratch!] for 2 secs

Transcript show: 'Hello from Smalltalk!'; cr.

SELECT 'Hello from SQL!';

print("Hello from Swift!")

puts "Hello from Tcl!"

console.log("Hello from TypeScript!");

int main() {
 stdout.printf("Hello from Vala!\n");
 return 0;
}

Module Module1
 Sub Main()
 Console.WriteLine("Hello from VB.NET!")
 End Sub
End Module

module hello;
 initial begin
 $display("Hello from Verilog!");
 $finish;
 end
endmodule

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 process
 begin
 report "Hello from VHDL!";
 wait;
 end process;
end Behavioral;

Module Module1
 Sub Main()
 Console.WriteLine("Hello from Visual Basic!");
 End Sub
End Module

Print["Hello from Wolfram Language!"]

<message>Hello from XML!</message>

message: Hello from YAML!

echo "Hello from Zsh!"

const std = @import("std");


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

(println "Hello from Clojure!")

puts "Hello from Crystal!"

import std.stdio;


void main() {
 writeln("Hello from D!");
}

class
 HELLO_WORLD


create
 make


feature


 make
 do
 print ("Hello from Eiffel!%N")
 end


end

." Hello from Forth!" cr
bye

main = putStrLn "Hello from Haskell!"

procedure main()
 write("Hello from Icon!")
end

'Hello from J!'

console.log("Hello from JavaScript!");

println("Hello from Julia!")

fun main() {
 println("Hello from Kotlin!")
}

(print "Hello from Lisp!")

print("Hello from Lua!")

Print["Hello from Mathematica!"]

#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Hello from Objective-C!");
 }
 return 0;
}

print_endline "Hello from OCaml!"

disp('Hello from Octave!');

{Show 'Hello from Oz!'}

program HelloWorld;


begin
 Writeln('Hello from Pascal!');
 Readln;
end.

print "Hello from Perl!\n";

<?php
echo "Hello from PHP!";
?>

BEGIN
 DBMS_OUTPUT.PUT_LINE('Hello from PL/SQL!');
END;
/

Write-Host "Hello from PowerShell!"

hello :-
 write('Hello from Prolog!'), nl.

module Main where


import Effect (Effect)
import Effect.Console (log)


main :: Effect Unit
main = log "Hello from PureScript!"

print("Hello from Python!")

/ Hello from Q

print("Hello from R!")

#lang racket
(displayln "Hello from Racket!")

print_endline("Hello from ReasonML!");

print "Hello from Rebol!"

see "Hello from Ring!" + nl

puts "Hello from Ruby!"

fn main() {
 println!("Hello from Rust!");
}

data _null_;
 put "Hello from SAS!";
run;

object Main {
 def main(args: Array[String]): Unit = {
 println("Hello from Scala!")
 }
}

(display "Hello from Scheme!")
(newline)

when green flag clicked
say [Hello from Scratch!] for 2 secs

Transcript show: 'Hello from Smalltalk!'; cr.

SELECT 'Hello from SQL!';

print("Hello from Swift!")


<AppearanceSection></AppearanceSection>